Post on 29-Dec-2014
CUADERNO DE EJERCICIOS Y PRACTICAS
CUADERNO DE TRABAJO DE
Cuaderno de Trabajo Visual Basic se encuentra bajo una Licencia
Comercial-Licenciamiento Recíproco 3.0 Unpo
[PROGRAMACION I – C++] IDSystems 2011
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página
CUADERNO DE TRABAJO DE C++
Cuaderno de Trabajo Visual Basic se encuentra bajo una Licencia Creative Commons Atribución
Licenciamiento Recíproco 3.0 Unported. Diciembre – IDSystems
tems 2011 - 2013
Página 1
C++
Creative Commons Atribución-No
IDSystems
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 2
Contenido PARTE I ............................................................................................................................................. 5
INSTRUCCIONES ................................................................................................................................ 6
Ejercicio 1 – Hola Mundo .................................................................................................................. 7
Ejercicio 2 – Tipos de datos ............................................................................................................... 7
Ejercicio 3 – Mezcla de tipos de datos ............................................................................................... 8
Ejercicio 4 – Simplificando comandos y datos ................................................................................... 9
Ejercicio 5 – Variables de preprocesador ......................................................................................... 10
Ejercicio 6 – Salida por pantalla ....................................................................................................... 11
Ejercicio 7 – Entrada y salida por pantalla ....................................................................................... 12
Ejercicio 8 – Operadores y tipos de datos ........................................................................................ 13
Ejercicio 9 – Operaciones simples ................................................................................................... 15
Ejercicio 10 - Concatenacion ........................................................................................................... 17
Ejercicio 11 – If…Else ....................................................................................................................... 18
Ejercicio 12 – Operaciones condicionales ........................................................................................ 19
Ejercicio 13 – IF…ELSE anidados ...................................................................................................... 21
Ejercicio 14 – Salida a un archivo externo ....................................................................................... 24
Ejercicio 15 - Switch ........................................................................................................................ 27
Ejercicio 16 – Area de poligonos con Switch .................................................................................... 28
Ejercicio 17 – Ciclo For .................................................................................................................... 31
Ejercicio 18 – Ciclo while ................................................................................................................. 33
Ejercicio 19 – Ciclos anidados .......................................................................................................... 34
Ejercicio 20 – Ciclo While ................................................................................................................ 35
PRACTICA 1 ..................................................................................................................................... 37
Ejercicio 21 - Juego del Granjero ..................................................................................................... 37
Ejercicio 22 - Juegos ........................................................................................................................ 48
Ejercicio 22a – Juego de Adivinanzas ........................................................................................... 49
Ejercicio 22b - Tragamonedas ..................................................................................................... 51
Ejercicio 22c – Pseudovirus ......................................................................................................... 54
Ejercicio 23 - Juego del Ahorcado .................................................................................................... 58
Ejercicio 24 - Juego Las Torres de Hanoi .......................................................................................... 73
Ejercicio 25 – Arreglos ..................................................................................................................... 78
Ejercicio 26 ..................................................................................................................................... 80
Ejercicio 27 – Cadenas .................................................................................................................... 82
Ejercicio 28 - Arreglos y cadenas ..................................................................................................... 84
Ejercicio 29 - Juego del Gato (Tic-Tac-Toe) ...................................................................................... 86
Ejercicio 30 – Estructuras ................................................................................................................ 90
Practica/Ejercicio 1 – Zodiaco ......................................................................................................... 92
Practica/Ejercicio 2 – Califaciones Estilo USA .................................................................................. 96
Practica/Ejercicio 3 – Sueldos a trabajador...................................................................................... 98
Practica/Ejercicio 4 – Promocion de Ventas .................................................................................. 100
Practica/Ejercicio 5 – Retraso en renta peliculas ........................................................................... 103
Practica/Ejercicio 6 – Dados .......................................................................................................... 105
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 3
PRACTICA 7 – Contando dinero ..................................................................................................... 108
PRACTICA 8 – Numeros ................................................................................................................. 108
PRACTICA 9 – Numeros ordenados ............................................................................................... 108
PRACTICA 10 – Boletos .................................................................................................................. 108
PRACTICA 11 – Conversiones metricas .......................................................................................... 108
PRACTICAS DE VARIABLES, TIPOS DE DATOS, ASIGNACIONES, OPERADORES ................................ 109
PRACTICA 12 – Rectangulo ........................................................................................................ 109
PRACTICA 13 – Pies ................................................................................................................... 109
PRACTICA 14 – Triangulo ........................................................................................................... 109
PRACTICA 15 – Raices ................................................................................................................ 109
PRACTICA 16 – Tiempos ............................................................................................................ 109
PRACTICA 17 – Prestamo .......................................................................................................... 109
PRACTICA 18 – Metros .............................................................................................................. 109
PRACTICA 19 – Millonario ......................................................................................................... 110
PRACTICA 20 – Promedio .......................................................................................................... 110
PRACTICA 21 – Circulo ............................................................................................................... 110
PRACTICA 22 – Maquina reversadora de numeros .................................................................... 110
PRACTICA 23 – Nibles ................................................................................................................ 110
PRACTICA 24 – Multiplicacion por 300 ...................................................................................... 110
PRACTICA 25 – Peso .................................................................................................................. 110
PRACTICA 26 – Fahrenheit ........................................................................................................ 110
PRACTICA 27 – Celsius ............................................................................................................... 110
PRACTICA 28 – Determinante .................................................................................................... 111
PRACTICA 29 – Don Manolo ...................................................................................................... 111
PRACTICA 30 - ISBN .................................................................................................................. 111
PRACTICA 31 – Odometer ......................................................................................................... 112
PRACTICA 32 – Triangulo II ........................................................................................................ 112
PRACTICA 33 – Distancia Euclidiana .......................................................................................... 112
PRACTICA 34 – Validacion de Tarjetas de credito ...................................................................... 112
PRACTICA 35 – Suma de fracciones ........................................................................................... 113
PRACTICAS DE ESTRUCTURAS DE CONTROL .................................................................................. 113
PRACTICA 36 – Max ................................................................................................................... 113
PRACTICA 37 – Positivo Negativo .............................................................................................. 113
PRACITCA 38 – Par Impar .......................................................................................................... 113
PRACTICA 39 – Convertidor de divisas ....................................................................................... 113
PRACTICA 40 – Grado Promedio ................................................................................................ 114
PRACTICA 41 – Bisiesto ............................................................................................................. 114
PRACTICA 42 – Diferencia.......................................................................................................... 114
PRACTICA 43 – Saludo ............................................................................................................... 114
PRACTICA 44 - Control .............................................................................................................. 114
PRACTICA 45 – Multiplo ............................................................................................................ 115
PRACTICA 46 – ASCII ................................................................................................................. 115
PRACTICA 47 – Super Raices ...................................................................................................... 115
PRACTICA 48 – Dia semana ...................................................................................................... 115
PRACTICA 49 – Super Triangulo ................................................................................................. 115
PRACTICAS DE ESTRUCTURAS REPETITIVAS ................................................................................... 115
PRACTICA 50 – Countdown ....................................................................................................... 115
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 4
PRACTICA 51 – Factorial ............................................................................................................ 115
PRACTICA 52 – Serie 1 ............................................................................................................... 116
PRACTICA 53 – Primo ................................................................................................................ 116
PRACTICA 54 – Ingenieros 2050 ................................................................................................ 116
PRACTICA 55 – Super Primos ..................................................................................................... 116
PRACTICA 56 – Mayor Menor .................................................................................................... 116
PRACTICA 57 – Cuadrado .......................................................................................................... 116
PRACTICA 58 – Decimal a Hexadecimal ..................................................................................... 116
PRACTICA 59 – Rombo .............................................................................................................. 116
PRACTICA 60 – Binario .............................................................................................................. 116
PRACTICA 61 – Tablas de Multiplicar ......................................................................................... 117
PRACTICA 62 – Divisores ........................................................................................................... 117
PRACTICA 63 – Calculadora ....................................................................................................... 117
PRACTICA 64 – Adivinar............................................................................................................. 117
PRACTICA 65 – Nicomaco .......................................................................................................... 117
PRACTICA 66 – Perfectos ........................................................................................................... 118
PRACTICA 67 – Sumatorias ........................................................................................................ 118
PRACTICA 68 – Guess my age .................................................................................................... 118
PRACTICA 69 – Power ............................................................................................................... 118
PRACTICA 70 – Amigos .............................................................................................................. 118
PRACTICAS CON VECTORES ........................................................................................................... 118
PRACTICA 71 – Minimo ............................................................................................................. 118
PRACTICA 72 – Cafeteria ........................................................................................................... 119
PRACTICA 73 – Traductor de Codigo Morse ............................................................................... 119
PRACTICA 74 – Serie .................................................................................................................. 119
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 5
PARTE I Los ejercicios y practicas de esta primera parte estan enfocados a entender los conceptos y el modo
de sintaxis de C++. Se vera la estructura basica de un programa, las instrucciones estandar y al
finalizar algunos ejemplos de comandos condicionales SI…ENTONCES.
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 6
INSTRUCCIONES
En este cuaderno de trabajo tendras los EJERCICIOS y PRACTICAS que veras en el curso de
Programacion I. Los ejercicios seran instrucciones paso a paso o programas ya resueltos para que los
teclees, te familiarices con la sintaxis, comados y realices alguna tarea sobre ellos como generar los
diagramas de flujo, pseudocodigo o indicar su funcionamiento. Las practicas, no tendran aquí la
respuesta, sino que deberas realizarla desde cero.
Debes teclear cada uno de los programas en tu compilador de C++. Hacer la compilacion y
encadenamiento y ver los resultados.
Recuerda que debes guardarlos y entregar tanto el compilado (.EXE) como el codigo fuente a tu
profesor. Ambos deben ir en un archivo ZIP como se describe a continuacion, si se los envias por
correo electronico:
Alumno_Grado_NoEjercicio...... Ejemplo: ReynolHernandez_03_Prog01.zip
Ademas, cada ejercicio debera ir acompañado de su diagrama de flujo y pseudocodigo.
Los programas fueron creados en Visual C++ 6.0, de la suite Microsoft Visual Studio 6.0 que
soporta hasta Windows XP. Para versiones Windows Vista y Windows 7, este compilador no
funcionara. Necesitaras descargar el Visual C++ 2008 Studio Express y posiblemente hacer
algunas modificaciones en el codigo.
Actualizacion 2013.
Desde el curso 2012, se utilizan 3 compiladores distintos para que el alumno aprenda las
diferencias entre los IDE y no propiamente en el lenguaje de C++. La primera parte
corresponde al compilador ZINJAI. La segunda parte al compilador MS Visual C++ 6.0 y la
tercera parte al compilador DevC++. Se han seleccionado estos compiladores porque se prestan
mejor para la manera didactica, aunque en la parte cuarta se utiliza ZINJAI con librerias
visuales y CODEBLOCKS. Los compiladores de NetBeans y Eclipse no se ven sino hasta el
siguiente curso.
En vista de que el compilador MS VISUAL C++ 6.0 no funciona de manera correcta en
Windows Vista, 7 y 8, se opto por utilizar la version Visual C++ 2008 Express o en su defecto
DevC++. Los ejercicios por tanto, mostraran codigo de ambas versiones.
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 7
Ejercicio 1 – Hola Mundo
1. El primer programa es el clasico HOLA MUNDO. Aqui lo hemos nombrado hola.cpp
Primero.cpp
#include <iostream> int main() { std::cout<< "Hola Mundo" ; return 0; }
Indica que es lo que hace cada linea:
Ejercicio 2 – Tipos de datos
El segundo programa trabaja con variables de tipo de dato entero, y usa la salida a la pantalla o
consola
Segundo.cpp
#include <iostream> int main() { int x = 5; int y = 7; std::cout << std::endl; std::cout << x + y << " " << x * y; std::cout << std::endl; return 0; }
Responde que es lo que hace cada una de las instrucciones:
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 8
SENTENCIA ACCION
Que tipo de variables declaramos?
Que operaciones estamos realizando?
Cual es el comando para mostrar salida por
pantalla?
Ejercicio 3 – Mezcla de tipos de datos
El tercer programa es una variacion del segundo que incorpora un tipo de dato caracter para mezclar
los dos
Segundob.cpp
#include <iostream> int main() { int x = 5; int y = 7; std::cout << std::endl; std::cout << "Estos son los valores: " ; std::cout << x << "y " << y; std::cout << std::endl; std::cout << x + y << " " << x * y; std::cout << std::endl; return 0; }
Cual es la diferencia entre este programa y el anterior?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 9
Ejercicio 4 – Simplificando comandos y datos
El cuarto programa es otra variacion del no. 2, pero aqui pedira una entrada por el teclado, se
almacena en una variable caracter y luego muestra todos los resultados.
Tercero.cpp
/* Tercero.cpp Este es el tercer programa y vamos a ver la entrada del teclado y salida por pantalla en la consola */ /* Esta es la libreria basica */ #include <iostream> /* Para no repetir la libreria std, la declaramos a qui */ using std::cout; using std::cin; int main() { int x = 5; int y = 7; char nombre [200]; cout << std::endl; cout<< "Estos son los valores: " <<x<< " y " << y; cout<< std::endl; cout << x + y << " " << x * y; cout << std::endl; cout << "Cual es tu nombre? " ; cin>>nombre; cout<< "Bienvenido " <<nombre<< ". Gracias por usar C++\n\n" ; return 0; }
Responde a lo que se indica:
SENTENCIA ACCION
Que tipo de datos estamos declarando?
Que operaciones estamos realizando?
Cual es el comando de salida en pantalla?
Cual es el comando de entrada de datos?
Cual es la instruccion para ENTER o indicar una
linea nueva?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 10
Ejercicio 5 – Variables de preprocesador
En este ejercicio veremos como usar variables para ejecutarse en el preprocesador
Prog05.cpp
/* Prog05_Case.cpp Un programa que pregunta su nombre y le saluda De: El C++ por la practica. FICHA 1. Pag. 15 Por: Lic. Sergio Hugo Sanchez O. Para: Universidad Valle del Bravo 17, Mayo,2009 */ #include <iostream> #define FRIEND 1 int main ( void ) { char name [200]; std::cout << "Escribe tu nombre \n" ; std::cin >> name; #ifdef FRIEND std::cout << "Hola " << name << ", que tal! \n" ; #endif return 0 ; }
Responde a lo que se indica:
Cual es la diferencia entre una variable normal y
las variables de preprocesador?
Como declaramos las variables de
preprocesador?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 11
Ejercicio 6 – Salida por pantalla
Simple programa de salida por pantalla
Prog06.cpp
/* Prog06_17.cpp Programa del ejercicio propuesto pag. 17 C++ por la practica. Para repasar la forma de mostrar mensajes en la pan talla. Por: Lic. Sergio Hugo Sanchez O. Para: Universidad Matamoros 17,Mayo, 2009 */ #include <iostream.h> int main( void ) { cout << "Esto del C++ parece muy facil" << endl; return 0; }
ZinJai /* Prog06_17.cpp Programa del ejercicio propuesto pag. 17 C++ por la practica. Para repasar la forma de mostrar mensajes en la pan talla. Por: Lic. Sergio Hugo Sanchez O. Para: Universidad Matamoros 17,Mayo, 2009 */ #include <iostream> using namespace std; int main(void) { cout << "Esto del C++ parece muy facil" << endl; return 0; }
Cual es la diferencia entre este programa y los que se han escrito anteriormente?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 12
Ejercicio 7 – Entrada y salida por pantalla
Entrada y salida por pantalla:
Prog07.cpp
/*Prog07_17.cpp Programa para el ejercicio propuesto en pag. 17 Man ual C++ por la practica 4.1 no. 2 Por: Lic. Sergio Hugo Sanchez O. Para: Universidad Matamoros 17, Mayo, 2009 */ #include <iostream.h> int main( void ) { char msg[200] ; cout << "Escribe un mensaje con una sola palabra: " <<endl; cin >> msg; cout << "*********************" <<endl; cout << msg << endl; return 0; }
/*Prog07_17.cpp Programa para el ejercicio propuesto en pag. 17 Man ual C++ por la practica 4.1 no. 2 Por: Lic. Sergio Hugo Sanchez O. Para: Universidad Matamoros 17, Mayo, 2009 */ #include <iostream> using namespace std; int main(void) { char msg[200] ; cout << "Escribe un mensaje con una sola palabra: "<<endl; cin >> msg; cout << "*********************"<<endl; cout << msg << endl; return 0; }
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 13
Que tipo de dato estamos declarando? Y como?
Ejercicio 8 – Operadores y tipos de datos
Programa que muestra el uso de operadores y tipos de datos
Prog08.cpp
/* Prog08_19.cpp Programa de la pagina 19 Curso C++ a la practica Para conocer los tipos basicos de datos en C Por: Lic. Sergio Hugo Sanchez O Para: Universidad Matamoros 17, Mayo, 2009 FICHA2 */ #include <iostream.h> int global = 5; int main ( void ) {
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 14
int a= 1; double x = 1.2 ; double y = 2.3 ; cout << "x+y=" <<x+y<< " " <<"a=" <<a<<endl; a=global + ( int ) x; cout<< "a=" <<a<<endl; return 0; }
/* Prog08_19.cpp Programa de la pagina 19 Curso C++ a la practica Para conocer los tipos basicos de datos en C Por: Lic. Sergio Hugo Sanchez O Para: Universidad Matamoros 17, Mayo, 2009 FICHA2 */ #include <iostream> using namespace std; int global = 5; int main (void) { int a= 1; double x = 1.2 ; double y = 2.3 ; cout << "x+y="<<x+y<<" "<<"a="<<a<<endl; a=global + (int) x; cout<<"a="<<a<<endl; return 0; }
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 15
INSTRUCCION ACCION
Que tipos de datos estamos declarando?
Que tipos de operaciones estamos realiznado?
Cual es el resultado del programa?
Ejercicio 9 – Operaciones simples
Otro ejemplo de operaciones simples con tipos de datos numericos
Prog09.cpp
/* Prog09_21.cpp Programa pag 21 El C++ por la practica Tipos de datos numericos y operaciones simples Por: Lic. Sergio Hugo Sanchez O. Para: Universidad Valle del Bravo 17, Mayo, 2009 Ficha2 */ #include <iostream.h> int main ( void ) { double x, y, z; cout << "Introduzca el primer numero" << endl; cin >> x; cout << "Introduzca el segundo numero" << endl; cin >> y; z = x+y; cout << x << "+" << y << "=" << z << endl; return 0; }
/* Prog09_21.cpp Programa pag 21 El C++ por la practica Tipos de datos numericos y operaciones simples Por: Lic. Sergio Hugo Sanchez O. Para: Universidad Valle del Bravo 17, Mayo, 2009 Ficha2 */ #include <iostream> using namespace std; int main (void) {
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 16
double x, y, z; cout << "Introduzca el primer numero" << endl; cin >> x; cout << "Introduzca el segundo numero" << endl; cin >> y; z = x+y; cout << x <<"+"<< y << "="<< z << endl; return 0; }
Realiza el pseudocodigo de este programa
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 17
Ejercicio 10 - Concatenacion
Suma de caracteres, tambien llamada CONCATENACION.
Prog11.cpp
/*Prog11.cpp Programa que permite la suma (concatenacion) de 2 c aracteres. Por: Lic. Sergio Hugo Sanchez O. Para: Universidad Matamoros 17, Mayo, 2009 Ficha 2 */ #include <iostream.h> int main ( void ) { char a; //declaracion de la variable tipo caracter char b; cout << "Introduzca el primer caracter: " << endl; cin >> a; cout << "Introduzca el segundo caracter: " << endl; cin >> b; a+=b; // a=a+b, suma o concatenacion de caracteres cout << "El resultado " << a; return 0;}
/*Prog11.cpp Programa que permite la suma (concatenacion) de 2 c aracteres. Por: Lic. Sergio Hugo Sanchez O. Para: Universidad Matamoros 17, Mayo, 2009 Ficha 2 */ #include <iostream> using namespace std; int main (void) { char a; //declaracion de la variable tipo caracter char b; cout << "Introduzca el primer caracter: " << endl; cin >> a; cout << "Introduzca el segundo caracter: " << endl ; cin >> b; a+=b; // a=a+b, suma o concatenacion de caracteres cout << "El resultado " << a; return 0;}
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 18
Responde a lo siguiente:
¿Qué es la concatenación?
¿Cómo se realiza la concatenación?
Ejercicio 11 – If…Else
Ejercicio para usar la sentencia IF/ELSE
Prog12.cpp
/* Sentencias tipo if/else. Anidamientos y operacio nes logicas */ #include <iostream.h> int main () { int i = 1; int j = 2; if (i>j) {cout << "i es mejor que j" <<endl;} else {cout << "i es mayor que j" <<endl;} return 0; }
/* Sentencias tipo if/else. Anidamientos y operacio nes logicas */ #include <iostream> using namespace std; int main () { int i = 1; int j = 2; if (i>j) {cout << "i es mejor que j"<<endl;} else {cout << "i es mayor que j"<<endl;} return 0; }
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 19
Explica el comando de IF
Ejercicio 12 – Operaciones condicionales
Ejercicio con operaciones, entrada salida por consola y condicional
Prog13.cpp
/* Pregunta dos numoers, que operacion deseas hacer y muestra el resultado */ #include <iostream.h> int main() { double a, b; int c; cout << "Introduce el primer numero " << endl; cin >> a; cout << "Introduce el segundo numero " << endl; cin >> b; cout << "Que operacion deseas hacer, 1(suma), 2(Multiplicac ion)? " << endl; cin >> c; if (c==1) {cout << "El resultado es: " << a+b<<endl;} else {cout << "El resultado es: " <<a*b<<endl;} return 0;
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 20
}
/* Pregunta dos numeros, que operacion deseas hacer y muestra el resultado */ #include <iostream> using namespace std; int main() { double a, b; int c; cout << "Introduce el primer numero " << endl; cin >> a; cout << "Introduce el segundo numero " << endl; cin >> b; cout << "Que operacion deseas hacer, 1(suma), 2(Mu ltiplicacion)? " << endl; cin >> c; if (c==1) {cout << "El resultado es: " << a+b<<end l;} else {cout <<"El resultado es: " <<a*b<<endl;} return 0; }
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 21
Realiza el pseudocódigo del programa anterior
Ejercicio 13 – IF…ELSE anidados
Ejercicio mas complejo de IF...ELSE anidados
Prog14.cpp
/*Calcular el area de diferentes poligonos */ #include <iostream.h> int main() { double a, b; double area; int figura; cout << "Figura= cuadrado (1), rectangulo (2), triangulo (3 )" << endl; cout << "¿que area deseas calcular)" << endl; cin >> figura; if (figura==1) { cout << "valor del lado=" ; cin >>a; area=a*a;} else if (figura==2) { cout << "Valor del lado menor = " ; cin >>a;
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 22
cout << "Valor del lado mayor = " ; cin >> b; area = a*b;} else if (figura==3) { cout << "Valor de la base =" ; cin >> a; cout << "Valor de la altura =" ; cin >> b; area=a*b/2.0;} else { cout << "figura equivocada" << endl; area=0;} cout << "El area de la figura es= " <<area<<endl; return 0; }
/*Calcular el area de diferentes poligonos */ #include <iostream> using namespace std; int main() { double a, b; double area; int figura; cout << "Figura= cuadrado (1), rectangulo (2), tri angulo (3)" << endl; cout << "¿que area deseas calcular)" << endl; cin >> figura; if (figura==1) { cout << "valor del lado="; cin >>a; area=a*a;} else if (figura==2) { cout << "Valor del lado menor = "; cin >>a; cout << "Valor del lado mayor = " ; cin >> b; area = a*b;} else if (figura==3) { cout <<"Valor de la base ="; cin >> a; cout << "Valor de la altura ="; cin >> b; area=a*b/2.0;} else { cout << "figura equivocada" << endl; area=0;} cout <<"El area de la figura es= "<<area<<endl;
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 23
return 0; }
ACCION COMANDO
¿Qué son las condiciones anidadas?
¿Cómo se escriben las condiciones anidadas?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 24
Ejercicio 14 – Salida a un archivo externo
Programa mas complejo que involucra: IF...ELSE, matrices, mas de 1 libreria, creacion de archivo de
texto, entrada y salida por pantalla. Nuevos comandos
Prog15.cpp
/* Se define la dimesion de un vector mediante un e ntero, el concepto de matriz se restringe de momento a un vector, se escribe un texto de salida mediante sentencia logica Aqui veremos otras librerias de C, como se crean lo s vectores y el uso de un archivo de texto */ #include <iostream.h> #include <fstream.h> #define MAX_SIZE 25 int main () { int size; ofstream MyReport( "resultado.txt" ); cout << "Introduzca la dimension del vector" <<endl; cin >> size; if (size > MAX_SIZE) { cerr << "Error, tamaño demasiado grande" << endl; MyReport << " *********************************** inicio" << endl; MyReport << " ERROR: dimesion del vector debe ser menor de " << MAX_SIZE <<endl; MyReport << " *********************************** fin" <<endl; MyReport.close(); return 1; } cout << "Vamos a trabajar con un vector de " << size << " componentes" << endl; MyReport << " *********************************** inicio" << endl; MyReport << " Vector de " << size << " componentes " <<endl; MyReport << " *********************************** fin" <<endl; MyReport.close(); return 0; }
/* Se define la dimesion de un vector mediante un e ntero, el concepto de matriz se restringe de momento a un vector, se escribe un texto de salida mediante sentencia
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 25
logica Aqui veremos otras librerias de C, como se crean lo s vectores y el uso de un archivo de texto */ #include <iostream> #include <fstream> using namespace std; #define MAX_SIZE 25 int main () { int size; ofstream MyReport("resultado.txt"); cout << "Introduzca la dimension del vector" <<end l; cin >> size; if (size > MAX_SIZE) { cerr << "Error, tamaño demasiado grande" << endl; MyReport << " *********************************** inicio" << endl; MyReport << " ERROR: dimesion del vector debe ser menor de " << MAX_SIZE <<endl; MyReport << " *********************************** fin"<<endl; MyReport.close(); return 1; } cout << "Vamos a trabajar con un vector de " << si ze << " componentes"<< endl; MyReport << " *********************************** inicio" << endl; MyReport << " Vector de " << size << " componentes " <<endl; MyReport << " *********************************** fin"<<endl; MyReport.close(); return 0; }
Indica lo siguiente:
¿Qué librerías estamos incorporando al
programa?
¿Qué es lo que hace el programa?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 26
¿Cuáles son los comandos de archivo que
se presentan?
Realiza el pseudocódigo correspondiente:
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 27
Ejercicio 15 - Switch
Programa de ejemplo para el Switch, variacion del primer programa IF...ELSE
Prog16.cpp
/* Uso de switch en lugar de IF Igual al prog13 */ #include <iostream.h> int main () { double a, b; int c; cout << "Introduzca el primer numero" <<endl; cin >> a; cout << "Introduzca el segundo numero" <<endl; cin >> b; cout << "Que operacion deseas hacer: 1(suma) 2(Multiplicacion)" <<endl; cin>>c; switch (c) { case 1: cout << "el resultado es:" <<a+b<<endl; break ; default : cout << "el resultado es:" <<a*b<<endl; break ; } return 0; }
/* Uso de switch en lugar de IF Igual al prog13 */ #include <iostream> using namespace std; int main () { double a, b; int c; cout << "Introduzca el primer numero"<<endl; cin > > a; cout << "Introduzca el segundo numero"<<endl; cin >> b; cout << "Que operacion deseas hacer: 1(suma) 2(Multiplicacion)"<<endl; cin>>c; switch (c) { case 1: cout << "el resultado es:"<<a+b<<endl; break; default: cout << "el resultado es:"<<a*b<<endl; break; } return 0; }
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 28
Menciona las diferencias entre la instrucción Switch y la instrucción IF
Ejercicio 16 – Area de poligonos con Switch Variacion de operaciones con poligonos usando switch en lugar de IF... else
Prog17.cpp
/*Calcular el area de diferentes poligonos usando S witch*/ #include <iostream.h> int main() { double a, b, area; int figura; cout << "Figura= rectangulo (1), triangulo (2)" << endl; cout << "¿que area deseas calcular)" << endl; cin >> figura; switch (figura) { case 1: cout << "Valor del lado menor = " ; cin >>a; cout << "Valor del lado mayor = " ; cin >> b; area = a*b; break ; case 2: cout << "Valor de la base =" ; cin >> a; cout << "Valor de la altura =" ; cin >> b; area=a*b/2.0; break ; default : cout << "figura equivocada" << endl; area=0; break ; } if (area) cout << "El area de la figura es= " <<area<<endl; else cerr << "error, la figura no tiene area" <<endl; return 0; }
/*Calcular el area de diferentes poligonos usando S witch*/ #include <iostream> using namespace std; int main() { double a, b, area; int figura; cout << "Figura= rectangulo (1), triangulo (2)" << endl; cout << "¿que area deseas calcular)" << endl; cin >> figura; switch (figura) { case 1: cout << "Valor del lado menor = "; cin >>a;
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 29
cout << "Valor del lado mayor = " ; cin >> b; area = a*b; break; case 2: cout <<"Valor de la base ="; cin >> a; cout << "Valor de la altura ="; cin >> b; area=a*b/2.0; break ; default: cout << "figura equivocada" << endl; area=0; break; } if (area) cout <<"El area de la figura es= "<<area <<endl; else cerr <<"error, la figura no tiene area"<<endl ; return 0; }
Prueba a hacer este programa sin ver el código aquí presentado, ya que es una variación del
ejercicio de polígonos usando el IF…else
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 30
PARTE II
En esta segunda parte se incluyen ejemplos para realizar ciclos. Ademas de incorporar funciones,
matrices, y ejemplos de algunos juegos los cuales preparan al estudiante en la logica de la
programacion.
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 31
Ejercicio 17 – Ciclo For 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. Prog19.cpp
// Este programa muestra una lista de números, indi cando para cada uno // si es o no múltipo de 3. // 11/09/2000 Salvador Pozo #include <iostream.h> // librería para uso de cout 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" ; // el resto de dividir por 3 es 0 else cout << " no es múltiplo de 3" ; // o no lo es cout << endl; // cambio de línea } return 0; }
DevC++ // Este programa muestra una lista de números, indi cando para cada uno // si es o no múltipo de 3. // 11/09/2000 Salvador Pozo #include <iostream> // librería 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"; // el resto de dividir por 3 es 0 else cout << " no es múltiplo de 3"; // o no lo e s cout << endl; // cambio de línea } system("pause"); return 0; }
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 32
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 código, 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.
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 33
Ejercicio 18 – Ciclo while 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". Prog20.cpp
// Este programa muestra una lista de números, indi cando para cada uno // si es o no múltipo de 3. #include <iostream.h> // librería para uso de cout // 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" ; // el numero es múltiplo de 3 else cout << " no es múltiplo de 3" ; // o no lo es cout << endl; // cambio de línea i++; } } // 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 ; }
// Este programa muestra una lista de números, indi cando para cada uno // si es o no múltipo de 3. #include <iostream> // librería 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" ; // el numero es múltiplo de 3
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 34
else cout << " no es múltiplo de 3"; // o no lo e s cout << endl; // cambio de línea i++; } system("pause"); } // 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.
Ejercicio 19 – Ciclos anidados Escribir un programa que muestre una salida de 20 líneas de este tipo: 1 1 2 1 2 3 1 2 3 4 ... Prog21.cpp
// Este programa muestra una lista de números // de este tipo: // 1 // 1 2 // 1 2 3 // ... #include <iostream.h> // librería para uso de cout 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 << i << " " ; // muestra el número cout << endl; // cambio de línea
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 35
} return 0; }
// Este programa muestra una lista de números // de este tipo: // 1 // 1 2 // 1 2 3 // ... #include <iostream> // librería 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 << i << " "; // muestra el número cout << endl; // cambio de línea } system("pause"); 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.
Ejercicio 20 – Ciclo While 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:
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 36
Prog21.cpp
/* Prog22 */ #include <iostream.h> int main() // función principal { int i = 1; / / variable para bucles bool sumar = true ; // Siguiente operación es sumar o restar bool terminado = false ; // Se ha alcanzado la condición de fin do { // Hacer cout << i; // muestra el valor en pantalla terminado = (i == 23); // Actualiza condición de fin if (terminado) cout << "." ; else cout << ", " ; // Puntuación, separadores if (sumar) i += 4; else i -= 2; // Calcula siguiente elemento sumar = !sumar; // Cambia la siguiente operación } while (!terminado); // ... mientras no se termine cout << endl; // Cambio de línea return 0; }
/* Prog22 */ #include <iostream> using namespace std; int main() // función principal { int i = 1; // variable para bucles bool sumar = true; // Siguiente operación es sumar o restar bool terminado = false; // Se ha alcanzado la condición de fin do { // Hacer cout << i; // muestra el valor en pantalla terminado = (i == 23); // Actualiza condición de fin if(terminado) cout << "."; else cout << ", "; // Puntuación, separadores if(sumar) i += 4; else i -= 2; // Calcula siguiente elemento sumar = !sumar; // Cambia la siguiente operación } while(!terminado); // ... mientras no se termine cout << endl;
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 37
// Cambio de línea system("pause"); return 0; }
PRACTICA 1 1.Ahora lee las paginas de la 32 a la 40 del manual el C++ por la practica y realiza los ejercicios propuestos ahí para enviarlos al profesor.
Ejercicio 21 - Juego del Granjero
Aqui vamos a hacer un alto o un parentesis en los temas que llevamos visto, para mostrar un
ejemplo mas practico y divertido sobre la programacion y sobre C++. Nada mejor que checar la
logica de un programa, asi como ver nuevas instrucciones que con un juego. Este programa incluye
algunas cosas que no se han visto hasta este momento en el curso. Como estructuras, funciones,
nuevas librerias y comandos (sentencias). Pero que por lo demas no son dificiles de entender.
1. Deberas teclear todo el codigo en C++
2. Deberas ejecutarlo... Y JUGARLO.
3. Deberas realizar el algoritmo. LINEA X LINEA del codigo del juego indicando que es lo que crees
que hace.
4. Si tienes una duda sobre alguna instruccion... consulta la ayuda del editor o en la wikipedia.
5. Opcial (para obtener mas puntos) realizar el diagrama de flujo del juego.
NOTA: Puedes usar el siguiente programa ONLINE y gratuito para hacer tu diagrama de
flujo. No olvides guardarlo o invitar al profesor con tu registro para que lo evalue.
http://www.gliffy.com/
He aqui el codigo:
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 38
granjero.cpp
/* * G R A N J E R O * * El problema del granjero cruzando el rio * */ #include <stdio.h> #include <stdlib.h> #include <conio.h> #define BELL 7 #define K_ESC 27 #define NBYTES 80 /* * Estructura de datos de los jugadores (bitfield) */ struct player_st { unsigned granjero : 1; unsigned zorra : 1; unsigned gallina : 1; unsigned maiz : 1; }; struct player_st Player; // variable generica bitfield /* * Prototipos de funcion */ void Instruct( void ); int GetMove( int ); void DoMove( int ); int CheckMap( int ); int MadeIt( void ); void YouLose( void ); void PrintMap( void ); int main() { int bank; //0 significa que el granjero esta en el banco izquierdo int move; // el codigo de la tecla para el movimiento requerido int trips; // numero de viajes a traves del rio char reply[NBYTES]; //respuesta del usuario /* * Poner las condiciones iniciales. Todos los eleme ntos estan en el * banco oeste y no se han hecho ningun viaje */ Player.granjero = Player.gallina = Player.zorra = Player.maiz = 0; bank = Player.granjero; trips = 0; printf( "\n============= GRANJERO =================\n" ); printf( "Presione ESC en cualquier tiempo para salir.\n\n" ); printf( "Necesita instrucciones? (Pulse S o N): " ); gets(reply);
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 39
if (reply[0] == 'S' || reply[0] == 's' ) Instruct(); PrintMap(); while (1) { move = GetMove(bank); DoMove(move); ++trips; bank = Player.granjero; PrintMap(); if (CheckMap(bank)) YouLose(); if (MadeIt()) break ; } printf( "Felicidades! Has llegado a salvo!\n" ); printf( "El numero de viajes fueron %d\n" , trips); return (0); } /* * Instruct() * * Despliega las reglas del juego * */ void Instruct() { printf( "**************************** INSTRUCCIONES ********************************** \n" ); printf( "Un granjero debe cruzar un rio en un bote.\n" ); printf( "El tiene una zorra, una gallina y un balde de maiz .\n" ); printf( "El granjero solo puede tomar una cosa a la vez en el bote.\n" ); printf( "La zorra no se puede quedar sola con la gallina po rque se la come.\n" ); printf( "Tampoco puede dejar a la gallina con el maiz.\n" ); printf( "Cuando el granjero esta presente, los animales se portan bien.\n" ); printf( "Usted es el granjero. Intente llegar desde el lado oeste del rio \n" ); printf( "al lado este con su equipaje a cuestas mientras ha ce el \n" ); printf( "posible numero de viajes.\n" ); } /* * * GetMove() * Hacer los movimientos */ int GetMove( int bank) { int key;
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 40
/* * Pregunte al usuario solo con los comandos dispon ibles. */ printf( "\nComandos: S(olo) " ); if (Player.zorra == bank) printf( "Z(orra) " ); if (Player.gallina == bank) printf( "G(allina) " ); if (Player.maiz == bank) printf( "M(aiz) " ); printf( ":" ); while (1) { key = toupper(getch()); if (key == 'S' ) break ; else if (key == 'Z' && Player.zorra == bank) break ; else if (key == 'G' && Player.gallina == bank) break ; else if (key == 'M' && Player.maiz == bank ) break ; else if (key == K_ESC) { putchar( '\n' ); exit (0); } else putchar(BELL); // mal comando } putchar( '\n' ); return (key); } void DoMove( int move) { switch (move) { case 'S' : break ; case 'Z' : Player.zorra = !Player.zorra; break ; case 'G' : Player.gallina = !Player.gallina; break ; case 'M' : Player.maiz = !Player.maiz; break ; } Player.granjero = !Player.granjero; } /* * CheckMap() * * Verificar que ningun elemento hostil se quedo sol o * Regresar 1 si lo estan o 0 si no */ int CheckMap( int bank) {
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 41
int status = 0; if (Player.zorra != bank && Player.gallina != bank) status = 1; if (Player.gallina !=bank && Player.maiz != bank) status = 1; return (status); } /* * PrintMap() * * Desplegar el mapa actual mostrando las posiciones * del granjero y los demas elementos */ void PrintMap() { char wc, ec; /* El granjero */ wc = ec = ' ' ; if (Player.granjero) ec = 'G' ; else wc = 'G' ; printf( "\n%c ^^^^^^ %c\n" ,wc, ec); /* La zorra */ wc = ec = ' ' ; if (Player.zorra) ec = 'z' ; else wc = 'z' ; printf( "\n%c ^^^^^^ %c\n" ,wc, ec); /* La gallina */ wc = ec = ' ' ; if (Player.gallina) ec = 'g' ; else wc = 'g' ; printf( "\n%c ^^^^^^ %c\n" ,wc, ec); /* El maiz */ wc = ec = ' ' ; if (Player.maiz) ec = 'm' ; else wc = 'm' ; printf( "\n%c ^^^^^^ %c\n" ,wc, ec); } /* * MadeIt() * * Determinar si todos los elementos fueron satisfac toriamente * transportados al lado este del rio */ int
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 42
MadeIt() { int status; status =0; if (Player.granjero && Player.zorra && Player.gallina && Player.maiz) status = 1; return (status); } /* * Cuando pierdes */ void YouLose() { printf( "Lo sentimos, has perdido. " ); if (Player.zorra == Player.gallina) printf( "La zorra se comio a la gallina.\n" ); else if (Player.gallina == Player.maiz) printf( "La gallina se comio el maiz.\n" ); exit(1); }
/* * G R A N J E R O * * El problema del granjero cruzando el rio * */ #include <stdio.h> #include <stdlib.h> #include <conio.h> #include <ctype.h> #define BELL 7 #define K_ESC 27 #define NBYTES 80 /* * Estructura de datos de los jugadores (bitfield) */ struct player_st { unsigned granjero : 1; unsigned zorra : 1; unsigned gallina : 1; unsigned maiz : 1; }; struct player_st Player; // variable generica bitf ield /* * Prototipos de funcion */ void Instruct(void); int GetMove(int);
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 43
void DoMove(int); int CheckMap(int); int MadeIt(void); void YouLose(void); void PrintMap(void); int main() { int bank; //0 significa que el granjero esta en el banco izquierdo int move; // el codigo de la tecla para el movimiento requerido int trips; // numero de viajes a traves del rio char reply[NBYTES]; //respuesta del usuario /* * Poner las condiciones iniciales. Todos los eleme ntos estan en el * banco oeste y no se han hecho ningun viaje */ Player.granjero = Player.gallina = Player.zorra = Player.maiz = 0; bank = Player.granjero; trips = 0; printf("\n============= GRANJERO ================= \n"); printf("Presione ESC en cualquier tiempo para sali r.\n\n"); printf("Necesita instrucciones? (Pulse S o N): "); gets(reply); if (reply[0] == 'S' || reply[0] == 's' ) Instruct(); PrintMap(); while (1) { move = GetMove(bank); DoMove(move); ++trips; bank = Player.granjero; PrintMap(); if (CheckMap(bank)) YouLose(); if (MadeIt()) break; } printf("Felicidades! Has llegado a salvo!\n"); printf("El numero de viajes fueron %d\n", trips); system("pause"); return (0); } /* * Instruct() * * Despliega las reglas del juego * */ void Instruct() { printf("**************************** INSTRUCCIONES ********************************** \n"); printf("Un granjero debe cruzar un rio en un bote. \n"); printf("El tiene una zorra, una gallina y un balde de maiz.\n");
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 44
printf("El granjero solo puede tomar una cosa a la vez en el bote.\n"); printf("La zorra no se puede quedar sola con la ga llina porque se la come.\n"); printf("Tampoco puede dejar a la gallina con el ma iz.\n"); printf("Cuando el granjero esta presente, los anim ales se portan bien.\n"); printf("Usted es el granjero. Intente llegar desde el lado oeste del rio \n"); printf("al lado este con su equipaje a cuestas mie ntras hace el \n"); printf("posible numero de viajes.\n"); system("pause"); } /* * * GetMove() * Hacer los movimientos */ int GetMove(int bank) { int key; /* * Pregunte al usuario solo con los comandos dispon ibles. */ printf("\nComandos: S(olo) "); if (Player.zorra == bank) printf("Z(orra) "); if (Player.gallina == bank) printf("G(allina) "); if (Player.maiz == bank) printf("M(aiz) "); printf(":"); while (1) { key = toupper(getch()); if (key == 'S') break; else if (key == 'Z' && Player.zorra == bank) break; else if (key == 'G' && Player.gallina == bank) break; else if (key == 'M' && Player.maiz == bank ) break; else if (key == K_ESC) { putchar('\n'); exit (0); } else putchar(BELL); // mal comando } putchar('\n'); return (key); } void
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 45
DoMove(int move) { switch (move) { case 'S': break; case 'Z': Player.zorra = !Player.zorra; break; case 'G': Player.gallina = !Player.gallina; break; case 'M': Player.maiz = !Player.maiz; break; } Player.granjero = !Player.granjero; } /* * CheckMap() * * Verificar que ningun elemento hostil se quedo sol o * Regresar 1 si lo estan o 0 si no */ int CheckMap(int bank) { int status = 0; if (Player.zorra != bank && Player.gallina != bank ) status = 1; if (Player.gallina !=bank && Player.maiz != bank) status = 1; return (status); } /* * PrintMap() * * Desplegar el mapa actual mostrando las posiciones * del granjero y los demas elementos */ void PrintMap() { char wc, ec; /* El granjero */ wc = ec = ' '; if (Player.granjero) ec = 'G'; else wc = 'G'; printf("\n%c ^^^^^^ %c\n",wc, ec); /* La zorra */ wc = ec = ' '; if (Player.zorra) ec = 'z'; else
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 46
wc = 'z'; printf("\n%c ^^^^^^ %c\n",wc, ec); /* La gallina */ wc = ec = ' '; if (Player.gallina) ec = 'g'; else wc = 'g'; printf("\n%c ^^^^^^ %c\n",wc, ec); /* El maiz */ wc = ec = ' '; if (Player.maiz) ec = 'm'; else wc = 'm'; printf("\n%c ^^^^^^ %c\n",wc, ec); } /* * MadeIt() * * Determinar si todos los elementos fueron satisfac toriamente * transportados al lado este del rio */ int MadeIt() { int status; status =0; if (Player.granjero && Player.zorra && Player.gall ina && Player.maiz) status = 1; return (status); } /* * Cuando pierdes */ void YouLose() { printf("Lo sentimos, has perdido. "); if (Player.zorra == Player.gallina) printf("La zorra se comio a la gallina.\n"); else if (Player.gallina == Player.maiz) printf("La gallina se comio el maiz.\n"); system("pause"); exit(1); }
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 47
Responde a lo siguiente:
¿Cual es el objetivo del juego?
¿Cuantas y cuales son las funciones que tiene el
juego?
¿Porque el juego esta dividido en funciones?
¿Cuales son las nuevas libreras incluidas?
¿Cuales son los commandos que sustituyen a
cout y cin?
¿Que tipo de datos estamos declarando y
como?
¿Que significa cada constante declarada?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 48
Ejercicio 22 - Juegos
Para terminar de ver los ejemplos acerca de las condicionales y los ciclos, vamos a ver 3 juegos mas.
Sin embargo, es importante hacer la siguiente aclaracion:
Estos juegos fueron adaptados de otras versiones de compilador C++. Como habiamos visto en la
primer leccion, hay varios compiladores de C++, y ademas del Microsot Visual C++, otro muy usado
es el Turbo C++ o Borland C++. Estos compiladores traen unas librerias no estandar de C, que
permiten extender un poco el lenguaje y facilitar algunas tareas en modo DOS para accesar algunas
funciones graficas.
De entre ellas, hay una libreria llamada CONIO.H y STDLIB.H, que si bien existen en la version del
compilador de Microsoft que estamos usando, no contiene las mismas instrucciones.
Por lo tanto, hay que seguir algunas reglas para que estos juegos funcionen y apliques estas nuevas
instrucciones que generalmente son utiles en los juegos. Sin embargo, algunas setenciones no se
recomiendan en su uso porque precisamente no son librerias estandar que puedan ser emuladas
facilmente.
Asi que habra que seguir un par de instrucciones para que estos programas funcionen de manera
correcta.
INSTRUCCIONES ANTES DE EJECUTAR LOS PROGRAMAS.
1. Ve a la seccion de Manuales y Video y deberas bajar CONSOLA.H y CONSOLA.LIB
2. Estos dos archivos deberas incluirlos donde este tu proyecto de programa.
3. Sera muy importante que primero crees un proyecto de programa, porque deberas anexar estos
dos archivos. Uno bajo HEADER y el otro bajo RESOURCES.
4. Ademas, deberas incluir el archivo CONSOLA.H al inicio de tu programa pero veras que en lugar
de <>, lo haras con " ", ya que, estaras indicando que sera de manera local.
5. Tambien se deberan sustituir algunas instrucciones (que veras como comentarios en algunos
casos) por otras compatibles con esta version del compilador (como RANDOM y RANDOMIZE).
Cualquier duda, preguntale a tu profesor.
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 49
Ejercicio 22a – Juego de Adivinanzas
El siguiente es un pequeño juego de adivinanzas. La computadora "pensara" un numero entre 1 y 100
y tu deberas adivinarlo en maximo 9 oportunidades.
prog22a_adivinanzas.cpp
#include <iostream.h> #include <conio.h> #include <stdlib.h> #include <time.h> void main(){ int i, a, b; //randomize(); //clrscr(); system( "cls" ); //a=rand()%100; srand(time(0)); a = 1 + rand() % 100; cout<< "A D I V I N A N Z A S\n" ; cout<< "Adivina el numero que estoy pensando\n" ; for (i = 1; i < 9; i++){ cin>>b; if (b == a) { cout<< "Muy bien, has acertado en " <<i<< " oportunidades \n" ; break ; } else if (b>a) cout<< "Es alto\n" ; else cout<< "Es bajo\n" ; } if (b != a) { cout<< "Lo siento, el numero es: " <<a <<endl; } }
#include <iostream> #include <conio.h> #include <stdlib.h> #include <time.h> using namespace std; int main(){ int i, a, b; //randomize(); //clrscr(); system("cls"); //a=rand()%100; srand(time(0)); a = 1 + rand() % 100; cout<<"A D I V I N A N Z A S\n"; cout<<"Adivina el numero que estoy pensando\n"; for (i = 1; i < 9; i++){ cin>>b; if (b == a) { cout<<"Muy bien, has acertado en "<<i<<" oportun idades \n"; break; }
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 50
else if (b>a) cout<<"Es alto\n"; else cout<<"Es bajo\n"; } if (b != a) { cout<<"Lo siento, el numero es: "<<a <<endl; } system("pause"); return 0; }
Aqui veras que se incluyen nuevas librerias. Ademas de nuevas instrucciones que no habiamos visto
hasta el momento. Te servira para repasar las instrucciones de condicion, contadores y generacion de
numeros aleatorios. Deberas descubrirlas y ver que es lo que hacen.
REALIZA:
El pseudocódigo El diagrama de flujo
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 51
Ejercicio 22b - Tragamonedas
Ahora, un pequeño juego muy popular en las vegas. El clasico tragamonedas, el cual cada vez que lo
ejecutes generara aleatoriamente las columnas con los elementos. Si le "atinas" a que las 3 columnas
contengan lo mismo... YA GANASTE!.
prog22b_tragamonedas.cpp
/* progb22b_tragamonedas.cpp JUEGO: El clasico de las Vegas. */ #include <iostream.h> #include <conio.h> #include <stdlib.h> #include <string.h> #include <dos.h> #include <time.h> #include "consola.h" void Frutas( int col); int i, a, b, c, m; char fruta[10][10]; int cuenta, columna = 0; int frutas[4]; void main() { //randomize(); //clrscr(); srand(time(0)); // for seed based on current time system( "cls" ); strcpy(fruta[0], "Melocoton" ); strcpy(fruta[1], "Melon" ); strcpy(fruta[2], "Sandia" ); strcpy(fruta[3], "Naranja" ); strcpy(fruta[4], "Piña" ); strcpy(fruta[5], "Fresa" ); strcpy(fruta[6], "Frambuesa" ); strcpy(fruta[7], "Mango" ); strcpy(fruta[8], "Pera" ); strcpy(fruta[9], "Durazno" ); // b = random(5); // c = random(5); b = 1 + rand() % 5; c = 1 + rand() % 5; for (cuenta =1; cuenta<=3; cuenta++) { columna += 20; Frutas(columna); frutas[cuenta] = a; } if (frutas[1]==frutas[2] && frutas[1]==frutas[3]) { gotoxy(24,20); cout<< "--- F e l i c i d a d e s h a s g a n a d o !!!" ; }
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 52
if (frutas[1]==frutas[2] || frutas[1]==frutas[3] || frutas[2]==frutas[3]) { gotoxy(24,20); cout<< "=== Ya casi ganas, te falto uno !!!" ; } getch(); } void Frutas( int col){ for (i=0; i<10; i++){ //a=random(10); //srand(time(0); //for seed based on current time srand(time(0)); a = 1 + rand() % 9; gotoxy(col, i ); cout<< " - " ; gotoxy(col, i ); cout<<fruta[a]; delay(100); gotoxy(col, i ); cout<< " " <<endl; } }
/* progb22b_tragamonedas.cpp JUEGO: El clasico de las Vegas. MOD: 18-Feb-2013 para adecuarlo a DevC++*/ #include <iostream> #include <conio.h> #include <stdlib.h> #include <string.h> #include <dos.h> #include <time.h> #include <windows.h> using namespace std; //Defines gotoxy() for ANSI C compilers. void gotoxy(short x, short y) { COORD pos = {x, y}; SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HA NDLE), pos); } void Frutas(int col); int i, a, b, c, m; char fruta[10][10]; int cuenta, columna = 0; int frutas[4]; int main() { //randomize(); //clrscr(); srand(time(0)); // for seed based on current time system("cls"); strcpy(fruta[0], "Melocoton"); strcpy(fruta[1], "Melon"); strcpy(fruta[2], "Sandia"); strcpy(fruta[3], "Naranja"); strcpy(fruta[4], "Piña"); strcpy(fruta[5], "Fresa"); strcpy(fruta[6], "Frambuesa"); strcpy(fruta[7], "Mango"); strcpy(fruta[8], "Pera");
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 53
strcpy(fruta[9], "Durazno"); // b = random(5); // c = random(5); b = 1 + rand() % 5; c = 1 + rand() % 5; for (cuenta =1; cuenta<=3; cuenta++) { columna += 20; Frutas(columna); frutas[cuenta] = a; } if (frutas[1]==frutas[2] && frutas[1]==frutas[3]) { gotoxy(24,10); cout<<"--- F e l i c i d a d e s h a s g a n a d o !!!"; } if (frutas[1]==frutas[2] || frutas[1]==frutas[3] | | frutas[2]==frutas[3]) { gotoxy(24,20); cout<<"=== Ya casi ganas, te falto uno !!!"; } //getch(); system("pause"); return 0; } void Frutas(int col){ for (i=0; i<10; i++){ //a=random(10); //srand(time(0); //for seed based on current ti me srand(time(0)); a = 1 + rand() % 9; gotoxy(col, i ); cout<<" - "; gotoxy(col, i ); cout<<fruta[a]; Sleep(100); gotoxy(col, i ); cout<<""<<endl; } }
Aqui repasaras sobre los ciclos y las condicionales. Asi con una pequeña funcion. Deberas realizar:
1) El codigo
2) El diagrama de flujo
Ademas indica lo siguiente:
¿Cuáles son las librerías que incorpora el
programa y que hacen cada una?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 54
¿Qué tipos de datos estamos declarando y como?
¿Qué funciones de C++ nuevas has descubierto
en el programa?
Ejercicio 22c – Pseudovirus
Quieres hacer una pequeña demostracion de un virus? Aqui tienes la oportunidad mientras practicas
los ciclos.
prog22c_pseudovirus.cpp
/* Pseudovirus.cpp Programa que muestra un supuesto virus en la pantal la Por: LSC Sergio Hugo Sanchez. NOTA: Recordar que necesitamos el archivo CONSOLA.H y CONSOLA.LIB en el mismo directorio del programa para compilar */ #include <iostream.h> #include <conio.h> #include <dos.h> #include <math.h> #include "consola.h" void derecha( int fila);
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 55
void izquierda( int fila); void final(); int col,i, j, r; void main(){ clrscr(); r=50; for (j=1; j<=50; j++) cout<< "---Auxilio!!! un virus al ataque al sistema " ; for (i=1; i<=25; i++) { if (i % 2 !=0 ) derecha(i); else izquierda(i); } final(); } // cambiar * por el codigo ASCII 176 (Si usas NOTEP AD++). Normal @ void derecha( int fila) { for (col=1; col<=6; col++) { delay(r); gotoxy(col,fila); cout<< "¦" ; } for (col=1; col<=74; col++) { delay(r); gotoxy(col,fila); cout<< "¦¦¦¦¦¦" ; } for (col=75; col<=80; col++) { delay(r); gotoxy(col,fila); cout<< " " ; } } void izquierda( int fila) { for (col=80; col>=74; col--) { delay(r); gotoxy(col,fila); cout<< "|" ; } for (col=74; col>=1; col--) { delay(r); gotoxy(col,fila); cout<< "||||||" ; } for (col=9; col>=1; col--) { delay(r); gotoxy(col,fila); cout<< " " ; } } //cambiar Ü por el codigo ASCII 220 (Si usas NOTEPA D++). Normal * void final() { clrscr(); gotoxy(20, 5); cout<< " ********** * * *" ; gotoxy(20, 6); cout<< " * * ** *" ; gotoxy(20, 7); cout<< " * * * * *" ; gotoxy(20, 8); cout<< " * * * * *" ; gotoxy(20, 9); cout<< " * * * * *" ; gotoxy(20,10); cout<< " ********** * * * *" ; gotoxy(20,11); cout<< " * * * * *" ; gotoxy(20,12); cout<< " * * * * *" ; gotoxy(20,13); cout<< " * * * * *" ; gotoxy(20,14); cout<< " * * * * *" ; gotoxy(20,15); cout<< " * * * * *" ; gotoxy(20,16); cout<< " * * * **" ; gotoxy(20,17); cout<< " * * * *" ;
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 56
delay(3000); clrscr(); delay(1000); }
/* Pseudovirus.cpp Programa que muestra un supuesto virus en la pantal la Por: LSC Sergio Hugo Sanchez. NOTA: Recordar que necesitamos el archivo CONSOLA.H y CONSOLA.LIB en el mismo directorio del programa para compilar MOD: 18-Feb-2013.. En la version DevC++ no necesita mos el header CONSOLA.H y la libreria asociada, basta usar la libreria wind ows.h y la pequena funcion al inicio. Ademas, se sustituye la funcion delay( ) por la funcion Sleep de la misma libreria windows.h */ #include <iostream> #include <conio.h> #include <dos.h> #include <math.h> #include <windows.h> using namespace std; //Defines gotoxy() for ANSI C compilers. void gotoxy(short x, short y) { COORD pos = {x, y}; SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HA NDLE), pos); } void derecha(int fila); void izquierda(int fila); void final(); int col,i, j, r; int main(){ //HANDLE hConsoleOutput; //hConsoleOutput = GetStdHandle(STD_OUTPUT_HAND LE); //SetConsoleDisplayMode(hConsoleOutput,1,NULL); system("cls"); r=50; for (j=1; j<=50; j++) cout<<"---Auxilio!!! un viru s al ataque al sistema "; for (i=1; i<=25; i++) { if (i % 2 !=0 ) derecha(i); else izquierda(i); } final(); system("pause"); return 0; }
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 57
// cambiar * por el codigo ASCII 176 (Si usas NOTEP AD++). Normal @ void derecha(int fila) { for (col=1; col<=6; col++) { Sleep(r); gotoxy(col,fila); cout<<"¦"; } for (col=1; col<=74; col++) { Sleep(r); gotoxy(col,fila); cout<<"¦¦¦¦¦¦"; } for (col=75; col<=80; col++) { Sleep(r); gotoxy(col,fila); cout<<" "; } } void izquierda(int fila) { for (col=80; col>=74; col--) { Sleep(r); gotoxy(col,fila); cout<<"|"; } for (col=74; col>=1; col--) { Sleep(r); gotoxy(col,fila); cout<<"||||||"; } for (col=9; col>=1; col--) { Sleep(r); gotoxy(col,fila); cout<<" "; } } //cambiar Ü por el codigo ASCII 220 (Si usas NOTEPA D++). Normal * void final() { system("cls"); gotoxy(20, 5); cout<<" ********** * * *"; gotoxy(20, 6); cout<<" * * ** *"; gotoxy(20, 7); cout<<" * * * * *"; gotoxy(20, 8); cout<<" * * * * *"; gotoxy(20, 9); cout<<" * * * * *"; gotoxy(20,10); cout<<" ********** * * * *"; gotoxy(20,11); cout<<" * * * * *"; gotoxy(20,12); cout<<" * * * * *"; gotoxy(20,13); cout<<" * * * * *"; gotoxy(20,14); cout<<" * * * * *"; gotoxy(20,15); cout<<" * * * * *"; gotoxy(20,16); cout<<" * * * **"; gotoxy(20,17); cout<<" * * * *"; Sleep(3000); system("cls"); Sleep(1000); }
Aqui veras bastantes ciclos for. Algunas instrucciones de pantalla y retardo.
Realiza:
1) El codigo
2) El diagrama de flujo.
Ademas indica lo siguiente:
¿Qué librerías incluye este programa?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 58
¿Qué tipos de datos estamos declarando?
¿Qué funciones propias estamos usando?
Ejercicio 23 - Juego del Ahorcado
Para seguir probando lo que son las funciones y como un programa se divide en estas para hacer mas facil de administrar, ahora veamos este juego un poco mas largo: el Ahorcado. Si bien, es un juego sencillo ya que solo acepta 3 palabras, contiene un menu inicial y la forma basica para jugarlo. En la seccion de practicas de este curso apareceran otros modelos de juego del ahorcado (incluso con graficas, mas temas y el uso de archivos para las palabras) que estan hechos en Borland C++ (en lugar de MS Visual C++) y con los cuales podras practicar. Mientras, divirtete y si quieres modifica el programa para que acepte mas palabras una vez que te funcione. Aqui aplicaremos los temas anteriores.
El programa esta un poco largo, pero te gustara:
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 59
prog23_ahorcado.cpp
/*Pro23_ahorcado.cpp Este es el juego del Ahorcado. Solamente contiene 3 palabras iniciales pero puede ser agrandado hasta donde quieras. Por: LSC Sergio Hugo Sanchez NOTA: No oldivar poner el header y libreria CONSOLA .H, CONSOLA.LIB en la misma carpeta */ #include <iostream.h> #include <conio.h> #include <stdio.h> #include <string.h> #include "consola.h" #define num_palabras 3 void construye_todo(); void captura_las_palabras(); void muestra_las_palabras(); void exhibe_el_menu(); void elegir_palabra(); void construye_cabeza(); void construye_tronco(); void construye_brazo_izquierdo(); void construye_brazo_derecho(); void construye_pie_izquierdo(); void construye_pie_derecho(); void construye_hora(); int opcion_elegida; int posicion_de_palabra_a_adivinar; int cant_de_palabras = num_palabras; int longitud_de_las_palabras[num_palabras]; char todas_las_palabras[20] [num_palabras]; char palabra_actual[20]; int logitud_palabra_actual=0; main() { opcion_elegida = 0; clrscr(); exhibe_el_menu(); getche(); return 0; } //************************************************* ********** void exhibe_el_menu( void ) { //clrscr(); do { gotoxy(25,2); printf( "PRESIONA EL NUMERO DE LA OPCION QUE DESEE" ); gotoxy(25,3); printf( "-----------------------------------------" );
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 60
gotoxy(25,3.5); printf( "-" ); gotoxy(59,3.5); printf( "!" ); gotoxy(25,4); printf( "- MENU DEL JUEGO EL AHORCADO !" ); gotoxy(25,5); printf( "- 1 - INGRESAR LAS PALABRAS !" ); gotoxy(25,6); printf( "- 2 - JUGAR EL AHORCADO !" ); gotoxy(25,7); printf( "- 3 - MOSTRAS LAS PALABRAS !" ); gotoxy(25,8); printf( "- 4 - ABANDONAR EL PROGRAMA !" ); gotoxy(25,9); printf( "----------------------------------------" ); gotoxy(25.5,15); printf( "ELIJA LA OPCION QUE DESEE Y PULSE ACEPTAR:" ); gotoxy(67,15); scanf( "%d" ,&opcion_elegida); } while (opcion_elegida < 1 || opcion_elegida > 4 ); switch (opcion_elegida) { case 1: captura_las_palabras(); case 2: elegir_palabra(); case 3: muestra_las_palabras(); case 4: break ; } } //************************************************* **************** void captura_las_palabras( void ) { int ia,ja; clrscr(); for (ia=0; ia<cant_de_palabras; ia++) { gotoxy(5,ia+10); printf( "ESCRIBA LA PALABRA NUMERO %d: " , ia+1); gotoxy(35,ia+10); cin>>palabra_actual; longitud_palabra_actual = strlen(palabra_actual); longitud_de_las_palabras[ìa] = longitud_palabra_a ctual; for (ja=0; ja<longitud_palabra_actual; ja++) todas_las_palabras[ja][ia]=palabra_actual[ja]; } exhibe_el_menu(); } //************************************************* *************** void muestra_las_palabras( void ) { int i,j; clrscr(); for (i=0; i<cant_de_palabras; i++) { gotoxy(5,i+10); printf( "PALABRA No %d: " , i+1); longitud_palabra_actual = longitud_de_las_palabra s[i]; for (j=0; j<longitud_palabra_actual; j++)
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 61
{ gotoxy(19+j, i+10); printf( "%c" , todas_las_palabras[j][i]); } } printf( "\n Pulse una tecla para continuar..." ; getche(); exhibe_el_menu(); } //************************************************* ************** void elegir_palabra( void ) { int longitud_de_palabra_a_adivinar, l; int i,j,sw=0, errores=0,contaP=0; char letra[l], completa[20]; clrscr(); do { gotoxy(10,4); printf( "Escriba un numero entre 1 y %d y pulse enter:" , cant_de_palabras); gotoxy(55,4); scanf( "%d" , &posicion_de_palabra_a_adivinar); clrscr(); } while (posicion_de_palabra_a_adivinar < 1 || posicion_de_palabra_a_adivinar > cant_de_palabras); longitud_de_palabra_a_adivinar = longitud_de_las_palabras[posicion_de_palabra_a_adiv inar-1]; for (i=0: i<longitud_de_palabra_a_adivinar; i++) { gotoxy(i+20,3); printf( "-" ); } do { i++; gotoxy(10,4); printf( "\n Escriba una Letra y Presione <Enter>..." ); cin>>letra; sw=0; for (j=0; j<longitud_de_palabra_a_adivinar; j++) { if (todas_las_palabras[j][posicion_de_palabra_a_adivin ar-1]==letra[0]) { gotoxy(j+20,3); printf( "%c" , letra[0]); completa[j]= letra[0]; sw=1; } } contaP=0; for (l=0; l<longitud_de_palabra_a_adivinar; l++) { if (completa[l]==todas_las_palabras[l][posicion_de_pal abra_a_adivinar-1]) contaP++;
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 62
} if (contaP=longitud_de_palabra_a_adivinar) { gotoxy(37,10); printf( "\nGANASTES EL JUEGO...." ); errores=4; i=longitud_de_palabra_a_adivinar; getch(); exhibe_el_menu(); } else { if (sw==0) errores++; if (errores==1) construye_cabeza(); else if (errores==2) construye_tronco(); else if (errores==3) construye_brazo_derecho(); else if (errores==4) construye_brazo_izquierdo(); else if (errores==5) construye_pie_derecho(); else if (errores==6) construye_pie_izquierdo(); else if (errores==7) { clrscr(); construye_todo(); errores=7; } } } while (i<longitud_de_palabra_a_adivinar || errores <=6); printf( "\n\n Pulse una tecla para continuar..." ); getche(); exhibe_el_menu(); } //************************************************* ************************ void construye_cabeza( void ) { gotoxy(39,6); printf( "|||||" ); gotoxy(38,7); printf( "| . . |" );
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 63
gotoxy(38,8); printf( "|_-_|" ); } //************************************************* ********************** void construye_tronco( void ) { gotoxy(41,9); printf( "|" ); gotoxy(41,10); printf( "|" ); gotoxy(41,11); printf( "|" ); gotoxy(41,12); printf( "|" ); } //************************************************* ******************* void construye_brazo_derecho( void ) { gotoxy(40,9); printf( "/" ); gotoxy(38,10); printf( "/" ); } //************************************************* ******************* void construye_brazo_izquierdo( void ) { gotoxy(42,9); printf( "\"); gotoxy(44,10); printf( "\"); } //************************************************* ****************** void construye_pie_izquierdo( void ) { gotoxy(42,13); printf( "" ); gotoxy(44,14); printf( "" ); } //************************************************* ****************** void construye_pie_derecho( void ) { gotoxy(40,13); printf( "/" ); gotoxy(38,14); printf( "/" ); } //************************************************* ***************** void construye_horca( void ) { int i; gotoxy(41,5); printf( ":" ); gotoxy(41,4);
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 64
printf( ":" ); gotoxy(41,3); printf( ":" ); gotoxy(42,3); printf( ":::::::::::::::" ); for (i=3; i<18; i++) { gotoxy(57,i); printf( ":" ); } gotoxy(50,i); printf( "===============" ); } //************************************************* ******************* void construye_todo( void ) { gotoxy(37,4); printf( "\nPERDISTE EL JUEGO......" ); construye_horca(); construye_pie_derecho(); construye_pie_izquierdo(); construye_brazo_derecho(); construye_brazo_izquierdo(); construye_tronco(); construye_cabeza(); }
/*Pro23_ahorcado.cpp Este es el juego del Ahorcado. Solamente contiene 3 palabras iniciales pero puede ser agrandado hasta donde quieras. Por: LSC Sergio Hugo Sanchez MOD: 18-Feb-2013 Actualizado para DevC++ */ #include <iostream> #include <conio.h> #include <stdio.h> #include <string.h> #include <windows.h> #define num_palabras 3 using namespace std; //Defines gotoxy() for ANSI C compilers. void gotoxy(short x, short y) { COORD pos = {x, y}; SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HA NDLE), pos); } void exhibe_el_menu(); void captura_las_palabras(); void muestra_las_palabras(); void construye_todo(); void elegir_palabra(); void construye_cabeza();
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 65
void construye_tronco(); void construye_brazo_izquierdo(); void construye_brazo_derecho(); void construye_pie_izquierdo(); void construye_pie_derecho(); void construye_horca(); int opcion_elegida=0; int posicion_de_palabra_a_adivinar=0; int cant_de_palabras = num_palabras; int longitud_de_las_palabras[num_palabras]; char todas_las_palabras[20] [num_palabras]; char palabra_actual[20]; int longitud_palabra_actual=0; int main() { opcion_elegida = 0; system("cls"); exhibe_el_menu(); system("pause"); return 0; } //************************************************* ********** void exhibe_el_menu(void) { system("cls"); do { gotoxy(25,2); printf("PRESIONA EL NUMERO DE LA OPCION QUE DESEE "); gotoxy(25,3); printf("----------------------------------------- "); // gotoxy(25,3.5); printf("-"); // gotoxy(59,3.5); printf("!"); gotoxy(25,4); printf("- MENU DEL JUEGO EL AHORCADO !"); gotoxy(25,5); printf("- 1 - INGRESAR LAS PALABRAS !"); gotoxy(25,6); printf("- 2 - JUGAR EL AHORCADO !"); gotoxy(25,7); printf("- 3 - MOSTRAS LAS PALABRAS !"); gotoxy(25,8); printf("- 4 - ABANDONAR EL PROGRAMA !"); gotoxy(25,9); printf("----------------------------------------" ); gotoxy(25,15); printf("ELIJA LA OPCION QUE DESEE Y PULSE ACEPTAR :"); gotoxy(67,15); scanf("%d",&opcion_elegida); } while (opcion_elegida < 1 || opcion_elegida > 4 ); switch (opcion_elegida) { case 1: captura_las_palabras(); case 2: elegir_palabra();
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 66
case 3: muestra_las_palabras(); case 4: break; } } //************************************************* **************** void captura_las_palabras(void) { int ia,ja; system("cls"); for (ia=0; ia<cant_de_palabras; ia++) { gotoxy(5,ia+10); printf("ESCRIBA LA PALABRA NUMERO %d: ", ia+1); gotoxy(35,ia+10); cin>>palabra_actual; longitud_palabra_actual = strlen(palabra_actual); longitud_de_las_palabras[ia] = longitud_palabra_a ctual; for (ja=0; ja<longitud_palabra_actual; ja++) todas_las_palabras[ja][ia]=palabra_actual[ja]; } exhibe_el_menu(); } //************************************************* *************** void muestra_las_palabras(void) { int i,j; system("cls"); for (i=0; i<cant_de_palabras; i++) { gotoxy(5,i+10); printf("PALABRA No %d: ", i+1); longitud_palabra_actual = longitud_de_las_palabra s[i]; for (j=0; j<longitud_palabra_actual; j++) { gotoxy(19+j, i+10); printf("%c", todas_las_palabras[j][i]); } } //printf("\n Pulse una tecla para continuar..."); //getche(); system("pause"); exhibe_el_menu(); } //************************************************* ************** void elegir_palabra(void) { int longitud_de_palabra_a_adivinar, l; int i,j,sw=0, errores=0,contaP=0; char letra[1]; char completa[20]; system("cls"); do { gotoxy(10,4); printf("Escriba un numero entre 1 y %d y pulse en ter:", cant_de_palabras); gotoxy(55,4); scanf("%d", &posicion_de_palabra_a_adivinar);
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 67
system("cls"); } while (posicion_de_palabra_a_adivinar < 1 || posicion_de_palabra_a_adivinar > cant_de_palabras); longitud_de_palabra_a_adivinar = longitud_de_las_palabras[posicion_de_palabra_a_adiv inar-1]; for (i=0; i<longitud_de_palabra_a_adivinar; i++) { gotoxy(i+20,3); printf("-"); } do { i++; gotoxy(10,4); printf("\n Escriba una Letra y Presione <Enter>.. ."); cin>>letra; sw=0; for (j=0; j<longitud_de_palabra_a_adivinar; j++) { if (todas_las_palabras[j][posicion_de_palabra_a_adivin ar-1]==letra[0]) { gotoxy(j+20,3); printf("%c", letra[0]); completa[j]= letra[0]; sw=1; } } contaP=0; for (l=0; l<longitud_de_palabra_a_adivinar; l++) { if(completa[l]==todas_las_palabras[l][posicion_de_ palabra_a_adivinar-1]) contaP++; } if (contaP=longitud_de_palabra_a_adivinar) { gotoxy(37,10); printf("\nGANASTES EL JUEGO...."); errores=4; i=longitud_de_palabra_a_adivinar; system("pause"); exhibe_el_menu(); } else { if (sw==0) errores++; if (errores==1) construye_cabeza(); else if (errores==2) construye_tronco(); else if (errores==3) construye_brazo_derecho(); else if (errores==4)
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 68
construye_brazo_izquierdo(); else if (errores==5) construye_pie_derecho(); else if (errores==6) construye_pie_izquierdo(); else if (errores==7) { system("cls"); construye_todo(); errores=7; } } } while (i<longitud_de_palabra_a_adivinar || error es <=6); //printf( "\n\n Pulse una tecla para continuar..." ); //getche(); system("pause"); exhibe_el_menu(); } //************************************************* ************************ void construye_cabeza() { gotoxy(39,6); printf("|||||"); gotoxy(38,7); printf("| . . |"); gotoxy(38,8); printf("|_-_|"); } //************************************************* ********************** void construye_tronco(void) { gotoxy(41,9); printf("|"); gotoxy(41,10); printf("|"); gotoxy(41,11); printf("|"); gotoxy(41,12); printf("|"); } //************************************************* ******************* void construye_brazo_derecho(void) { gotoxy(40,9); printf("/"); gotoxy(38,10);
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 69
printf("/"); } //************************************************* ******************* void construye_brazo_izquierdo(void) { gotoxy(42,9); printf("*"); gotoxy(44,10); printf("*"); } //************************************************* ****************** void construye_pie_izquierdo(void) { gotoxy(42,13); printf("*"); gotoxy(44,14); printf("*"); } //************************************************* ****************** void construye_pie_derecho(void) { gotoxy(40,13); printf("/"); gotoxy(38,14); printf("/"); } //************************************************* ***************** void construye_horca(void) { int i; gotoxy(41,5); printf(":"); gotoxy(41,4); printf(":"); gotoxy(41,3); printf(":"); gotoxy(42,3); printf(":::::::::::::::"); for (i=3; i<18; i++) { gotoxy(57,i); printf(":"); } gotoxy(50,i); printf("==============="); } //************************************************* ******************* void construye_todo(void) { gotoxy(37,4); printf("\nPERDISTE EL JUEGO......"); construye_horca(); construye_pie_derecho(); construye_pie_izquierdo(); construye_brazo_derecho(); construye_brazo_izquierdo();
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 70
construye_tronco(); construye_cabeza(); }
DevC++
con
WimbGi
m
/* Dev_prog23bG Juego del Ahorcado de manera grafica Gracias a: TRABAJO FINAL DE COMPUTACION PAZ CARDENAS ISRAEL EDSON ESCOBAR CHAINA PABLO WILSON MEDRANO AROSQUETA FREDDY (creadores originales) */ #include <iostream> #include <stdlib.h> #include <stdio.h> #include <String.h> #include <winbgim.h> using namespace std; int main() { int x=20; system("color e1"); char texto[20]; cout<< "\n"; cout<< "\n"; cout<< " ===== JUEGO DEL AHORCADO ===== \n"; cout<< "\n"; cout<< "\n"; cout<< " ===== Escriba la palabra que desea adiv inar ? ===== \n"; cout<< "\n"; cout<< "\n"; cin>> texto; cout<< "\n"; int n=strlen(texto); char otro[n]; for (int i=0;i < n;i++) { otro[i]='-'; } char letra[2]; int ce=0, completa=0, encontrado; initwindow(300,300); setcolor(4); settextstyle(0,0,2); outtextxy(20,250,"= EL AHORCADO ="); outtextxy(50,30,otro); while (ce < 5 && completa==0) { cout<< " Escriba la letra para completar la p alabra ? \n"; cout<< "\n"; cin>> letra; encontrado=0;
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 71
for (int i=0;i < n;i++) { if(texto[i]==letra[0]) { encontrado=1; otro[i]=letra[0]; cout<< "\n"; cout<< " Letra acertada "; cout<< "\n"; } } if(encontrado==0) { ce++; switch(ce) { case 1: circle(100,90,20); break; case 2:line(100,110,100,180); break; case 3: line(100,125,65,170); line(100,125,135,170); break; case 4: line(100,180,60,220); line(100,180,140,220); break; case 5: line(100,120,140,120); line(140,120,140,50); line(140,50,45,50); line(45,50,45,240); line(45,240,160,240); setcolor(2); line(90,80,110,100); line(90,100,110,80); outtextxy(10,250," PERDEDOR !!!! "); break; } } completa=1; for (int i=0;i < n;i++) { if(otro[i]=='-') { completa=0;} } cout<< otro <<endl; outtextxy(50,30,otro); } system("pause"); closegraph(); return 0; }
NOTA:
Recuerda que algunas funciones de este programa son una emulacion de la biblioteca original
conio.h de Borland C++, por lo que deberas incluir el archivo header CONSOLA.H y la
libreria CONSOLA.LIB, si es que trabajas en MS Visual C++ 6.0 o MS Visual C++ 2008
Express.
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 72
Ademas, compara que el codigo para DevC++ no utiliza la librería consola.h y en su defecto
utiliza la librería windows.h. Este programa tiene errores de manera intencional para las
versiones de Visual C++ y DevC++. Descubrelos y da una solucion, ademas:
Se ha incorporado otro codigo del ahorcado de manera grafica utilizando la librería
wimbgim.h. Para lo cual buscala en internet o pidela a tu profesor. Deberas instalar esta
librería para tu compilador DevC++, y crear un proyecto nuevo bajo Console Graphics
Application, en lugar de Console Application tradicional. Una vez hecho esto, teclea el codigo
correspondiente y compila.
Responde a lo siguiente:
¿Qué librerías son las que se incluyen en este
programa?
¿Cuáles son las funciones en las que esta
dividido este programa?
¿Cuáles son los nuevos comandos de C, que se
incluyen en este programa?
¿Qué tipos de datos se declaran en este
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 73
programa?
¿Dónde se almacenan las palabras?
¿Cómo se pueden poner mas palabras?
¿Qué función o proceso es lo que mas realiza
este programa y se repite?
Ejercicio 24 - Juego Las Torres de Hanoi Generalmente para probar el tema de la recursividad se aplica el ejercicio del juego de las torres de Hanoi. En este juego, el usuario tiene que mover unos aros que estan desde el poste 1 hasta el poste 3, pasando a veces por el poste 2, de tal forma que queden acomodados de menor a mayor hacia abajo como estaban en el poste 1. Prueba hacer el codigo siguiente en MS Visual C++ prog24_hanoi.cpp
/*prog24_hanoi.cpp Programa de la Torre de Hanoi Por: Enrique R. Mosqueda */ #include <stdio.h> #include <conio.h> #include <math.h> /* include <windows.h> #define BG_BLACK (0) #define FG_RED (12) #define FG_BLUE (9) #define FG_WHITE (15)
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 74
#define FG_GREEN (2) */ //void clrscr() /* { HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE), COORD cor = {0,0}, DWORD count; CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(hStdOut, &csbi); FillConsoleOutputCharacter(hStdOut, ' ', csbi.dvS ize.X * csbi.dvSize.Y, coord, &count); SetConsoleCursorPosition(hStdOut, coord); }*/ void Towers( int , int , char , char , char ); int n=0, a=0, b=0, c=0; void main() { //clsscr(); printf( "\n\n\t\tTORRE DE HANOI\n" ); printf( "CREADO POR ENRIQUE RADHAMES MOSQUEA MARTINEZ\n"); printf( "las torres estan representadas como A,B,C\n" ); printf( "Digite el 0 para salir del sistema.\n" ); printf( "Digite la cantidad de Discos ===> " ,n); scanf( "%d" ,&n); Towers( n,a, 'A' , 'B' , 'C' ); c=((a+b)-1); printf( "\n\n Con %d DISCOS %d" , n, c); printf( "\n\tEl numero de Dias es => %d" , c); printf( "\n\n\n\tnota: estas variables solo alcanzan para 3 0 discos" ); printf( "\n\ty usando la funcion POW(2,n)-1" ); c=pow(2,n)-1; printf( "\n\tEl resultado es el mismo => %d" ,c); printf( "\n\tpara jugar con los colores solo activen las funciones" ); printf( "\n\tque estan como comentarios." ); printf( "\nEspero que les guste " ); getch(); } /* juego del sistema */ void Towers( int n, int a, char frompeg, char topeg, char auxpeg ) { /* HANDLE hStdInput = INVALID_HANDLE_VALUE, hStdOutPut = INVALID_HANDLE_VALUE; hStdInput = GetStdHandle(STD_INPUT_HANDLE); hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE); SetConsoleTextAttribute(hStdOutput, BG_BLACK | FG_ RED); */ if (n==1) { b=b+2; c*=a+b; printf( "\n%s%d%s%c%s%c", "\t\t\t DISCO " , n, " DESDE " , frompeg, " HACIA " , topeg, a); return ; } a=a+1; Towers( n-1,a, frompeg, auxpeg, topeg); //SetConsoleTextAttribute(hStdOutput, BG_BLACK | FG _BLUE ); printf( "\n%s%d%s%c%s%c", "\t\t\t DISCO " , n, " DESDE " , frompeg, " HACIA " , topeg, a); Towers( n-1,a, frompeg, auxpeg, topeg);
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 75
//SetConsoleTextAttribute(hStdOutput, BG_BLACK | FG _BLUE ); }
Para la version DevC++, solo hay que cambiar unas lineas que esperamos ya hayas identificado. Y despues, ve a la seccion de BIBLIOTECA\DESCARGAS y baja el archivo de HANOIG (BORLAND), para que ejecutes el ejecutable. Este ultimo programa esta escrito en Borland C++ y utiliza bibliotecas graficas de MSDOS.
NOTA: En ambos es posible que solo veas a la computadora jugar. ¿Podrias modificar el programa para que tu seas el que haga los movimientos? Es un buen reto. =)
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 76
Responde a lo que se indica:
¿Qué es la recursión?
¿Por qué están varias
instrucciones con
comentarios?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 77
PARTE III
ARREGLOS Y ESTRUCTURAS
A partir de aquí, usamos solamente el compilador DevC++.
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 78
Ejercicio 25 – Arreglos Realiza la siguiente practica, tecleando los siguientes programas para que veas el funcionamiento de los arreglos. Primero un programa que cuenta los numeros sin usar arrelgos:
prog24_vectores.cpp
/* prog24 - Ejemplo de vectores */ #include <stdio.h> #define MAX 100 //Declara funcion de vectores //void vectores() // Comenzamos con la funcion normal /* A continuaci´on se muestra un programa que cuent a el numero de apariciones de los numeros 0, 1, 2 y 3 en una secuencia de enteros acabada en -1. */ int main() { int num, c0=0, c1=0, c2=0, c3=0; printf( "El siguiente programa cuenta en numero de aparicio nes de los numeros 0 al 3\n" ); printf( "Por lo que se te preguntara por un numero, tecleal o y pulsa ENTER \n" ); printf( "Para finalizar el ciclo, teclea -1 y te apaceran l os resuñtados \n\n" ); scanf( "%d" , &num); while (num != -1) { if (num == 0) c0++; if (num == 1) c1++; if (num == 2) c2++; if (num == 3) c3++; scanf( "%d" , &num ); } printf( "Resultado Contadores:%d, %d, %d, %d \n\n" , c0, c1, c2, c3 ); return 0; }
Y ahora basado en el mismo concepto de contar numeros, usando arrays:
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 79
prog30_vectores.cpp
/* Pro30 - Uso de vectores */ /* ¿Que ocurriria si tuviesemos que contar las apar iciones de los cien primeros numeros enteros? ¿Deber´ýamos declarar ci en contadores y escribir cien construcciones if para cada caso? La respuesta, como era de esperar, se halla en el uso de vectores. Veamoslo en el siguiente codigo que llama a la func ion: */ #include <stdio.h> #define MAX 100 int main() { int i, num2, cont[MAX]; printf( "El siguiente programa cuenta en numero de aparicio nes de los numeros 0 al 3\n" ); printf( "Por lo que se te preguntara por un numero, tecleal o y pulsa ENTER \n" ); printf( "Para finalizar el ciclo, teclea -1 y te apaceran l os resuñtados \n\n" ); for (i= 0; i< MAX; i++) cont[i] = 0; scanf( "Numero %d" , &num2); while (num2 != -1) { if ((num2 >= 0) && (num2 <= MAX)) cont[num2]++; scanf( "%d" , &num2 ); } for (i= 0; i< MAX; i++) printf( "Contador [%d] = %d \n\n" , i, cont[i] ); return 0; }
Responde a lo siguiente:
¿Cuál es la diferencia entre los dos programas?
¿Cómo declaramos las variables en ambos programas?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 80
¿Por qué cambiaron las instrucciones para los ciclos?
Ejercicio 26 Ahora un ejercicio para aprender sobre arrays multidimensionales:
prog31.cpp
/* Prog31 - Arrays multidimensionales El siguiente ejemplo muestra el empleo de una tabla multidimensional. Concretamente, el programa utiliza una tabla de 3 d imensiones para almacenar 1000 numeros aleatorios. Para generar numeros aleatorios se usa la funcion rand de la libreria estandar stdlib.h. Tambien se ha usado la funcion getchar (s tdio.h), que interrumpe el programa y espera a que el usuario presione una tecla. */ #include <stdio.h> #include <stdlib.h> #define DIM 10 void main() { int tabla_random [DIM][DIM][DIM], a, b, c; for (a= 0; a< DIM; a++) for (b= 0; b< DIM; b++) for (c= 0; c< DIM; c++) tabla_random[a][b][c] = rand(); /* Muestra series de DIM en DIM elementos. */ for (a= 0; a< DIM; a++) for (b= 0; b < DIM; b++) { for (c= 0; c < DIM; c++) { printf( "\n\n tabla[%d][%d][%d] = " , a, b, c ); printf( "%d" , tabla_random[a][b][c] ); } printf( "\n\nPulse ENTER para seguir" ); getchar(); } }
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 81
Responde a lo siguiente:
¿Que son los arrays multidimensionales?
¿Como generamos los numerous aleatorios?
¿Como declaramos las variables?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 82
Ejercicio 27 – Cadenas Para repasar los temas, realiza estos dos programas:
prog32.cpp
/* Prog32 - Ejemplo de cadenas El siguiente programa cuenta el numero de veces que se repite una palabra en una frase. El programa emplea la funcion de comparacion de cad enas strcmp. Dicha funcion devuelve 0 en caso de que las cadenas comparadas sean iguales */ #include <stdio.h> #include <string.h> #define MAXLIN 100 void main() { char pal[MAXLIN]; /* La que buscamos. */ char palfrase[MAXLIN]; /* Una palabra de la frase. */ char c; int total = 0; printf( "\nPALABRA:" ); scanf( "%s" , pal ); printf( "\nFRASE:" ); c= ' ' ; while (c != '\n' ) { scanf( "%s%c" , palfrase, &c ); if (strcmp(pal, palfrase) == 0) total++; } printf( "\nLa palabra %s aparece %d veces." , pal, total ); }
Y tambien este otro:
prog33.cpp
/* Prog33 - Otro ejemplo de cadenas A continuacion se muestra otro ejemplo que hace uso de las cadenas de caracteres. El programa lee dos cadenas de caracteres, las conc atena, convierte las letras minusculas en mayusculas y viceversa, y finalmente escribe la cadena resultante. */ #include <stdio.h> #include <string.h> void main() { char cad1[80], cad2[80], cad3[160];
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 83
int i, delta; printf( "Introduzca la primera cadena:\n" ); gets(cad1); printf( "Introduzca la segunda cadena:\n" ); gets( cad2 ); /* cad3 = cad1 + cad2 */ strcpy( cad3, cad1 ); strcat( cad3, cad2 ); i = 0; delta = 'a' - 'A' ; while (cad3[i] != '\0' ) { if ((cad3[i] >= 'a' ) && (cad3[i] <= 'z' )) cad3[i] -= delta; /* Convierte a mayuscula */ else if ((cad3[i] >= 'A' ) && (cad3[i] <= 'Z' )) cad3[i] += delta; /* Convierte a minuscula */ i++; } printf( "La cadena resultante es: %s \n" , cad3 ); }
Responde a lo siguiente: ¿Qué es lo que hace el primer programa?
¿Qué es lo que hace el segundo programa?
¿Cuáles son las funciones de cadena que usan estos programas?
¿Cuáles son las instrucciones de entrada en los dos programas?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 84
¿Cómo se declaran las variables en ambos programas y por que de esa manera?
Ejercicio 28 - Arreglos y cadenas Para repasar la leccion anterior sobre los arrays, realiza el siguiente ejercicio para que veas como se determinan y que resultados muestran: prog23_arrays.cpp
/* ej4.c Inicializacion y manejo de "arrays", cadenas y estr ucturas. */ # include <stdio.h> void main() { int i, j; //Aqui inicializamos los arrays, tanto de numeros c omo de cadenas static int enteros [5] = { 3, 7, 1, 5, 2 }; static char cadena1 [16] = "cadena" ; static char cadena2 [16] = { 'c' , 'a' , 'd' , 'e' , 'n' , 'a' , '\0' }; //Ahora inicializamos las estructuras de datos static int a[2][5] = { { 1, 22, 333, 4444, 55555 }, { 5, 4, 3, 2, 1 } }; static int b[2][5] = { 1,22,333,4444,55555,5,4,3,2,1 }; static char *c = "cadena" ; static struct { int i; float x; } sta = { 1, 3.1415e4}, stb = { 2, 1.5e4 }; static struct { char c; int i; float s; } st [2][3] = { {{ 'a' , 1, 3e3 }, { 'b' , 2, 4e2 }, { 'c' , 3, 5e3 }}, { { 'd' , 4, 6e2 },} }; //Aqui pondremos los resultados de dichos arrays y estructuras. // Comenzamos con las cadenas
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 85
printf ( "enteros:\n" ); for ( i=0; i<5; ++i ) printf ( "%d " , enteros[i]); printf ( "\n\n" ); printf ( "cadena1:\n" ); printf ( "%s\n\n" , cadena1); printf ( "cadena2:\n" ); printf ( "%s\n\n" , cadena2); printf ( "a:\n" ); //Que nos muestra las variables enteros en este cic lo? for (i=0; i<2; ++i) for (j=0; j<5; ++j) printf ( "%d " , a[i][j]); printf( "\n\n" ); printf ( "b:\n" ); //Ahora mostremos las estructuras de datos de numer os for (i=0; i<2; ++i) for (j=0; j<5; ++j) printf ( "%d " , b[i][j]); printf ( "\n\n" ); printf ( "c:\n" ); printf ( "%s\n\n" , c); printf ( "sta:\n" ); printf ( "%d %f \n\n" , sta.i, sta.x); printf ( "st:\n" ); for (i=0; i<2; ++i) for (j=0; j<3; ++j) printf ( "%c %d %f\n" , st[i][j].c, st[i][j].i, st[i][j].s); }
Responde a lo siguiente:
Que variables declaramos en este
programa?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 86
Que funcion tienen la instruccion static?
Cual es la descripcion del formato que usa
la funcion printf?
Ejercicio 29 - Juego del Gato (Tic-Tac-Toe) A continuacion se presenta el juego del gato o Tres en raya (Tic-Tac-Toe en ingles), para aprender un poco mas sobre las matrices y ver su aplicacion. Teclea el codigo siguiente y ejecutalo, ademas tendras que traducirlo porque los mensajes estan en ingles. Que te diviertas!!!
prog35_juegogato.cpp
#include <iostream.h> #include <stdlib.h> #include <conio.h> char matrix[3][3]; //={0} void playbox( void ); int main() { int m, n; char ch= 'y' ; while (ch== 'Y' || ch == 'y' ) { for (m=0; m<3; m++) for (n=0; n<3; n++) matrix[m][n]= '\0' ; int i,j, sum=0; while (sum<10)
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 87
{ if (sum==0) playbox(); cout<< "Player 1 is 'X': choose the row and column" <<endl; cout<< "Row : " ; cin>>i; cout<< "Coumn : " ; cin>>j; for (;i>3 || i<1 || j>3 || j<1 || ( 'X' ==matrix[i-1][j-1] || 'O' ==matrix[i-1][j-1]);) { cout<< "Sorry boy, but you gotta choose another place.\n" ; cout<< "Row : " ; cin>>i; cout<< "Column : " ; cin>>j; } matrix[i-1][j-1]= 'X' ; sum++; playbox(); //Check if wins if (matrix[0][0]== 'X' && matrix[0][0]==matrix[1][1] && matrix[1][1]==matrix[ 2][2]) { if (matrix[2][0]== 'X' && matrix[2][0]==matrix[1][1] && matrix[1][1]==matrix[ 0][2]) { if (matrix[0][0]== 'X' && matrix[0][0]==matrix[1][0] && matrix[1][0]==matrix[ 2][0]) { if (matrix[0][1]== 'X' && matrix[0][1]==matrix[1][1] && matrix[1][1]==matrix[ 2][1]) { if (matrix[0][2]== 'X' && matrix[0][2]==matrix[1][2] && matrix[1][2]==matrix[ 2][2]) { if (matrix[0][0]== 'X' && matrix[0][0]==matrix[0][1] && matrix[0][1]==matrix[ 0][2]) { if (matrix[1][0]== 'X' && matrix[1][0]==matrix[1][1] && matrix[1][1]==matrix[ 1][2]) { if (matrix[2][0]== 'X' && matrix[2][0]==matrix[2][1] && matrix[2][1]==matrix[ 2][2]) { } if (sum==9) { //sum=9 because there are only 9 boxes in the game cout<< "The game is over and no one wins, hahaha, you both stink!!!" <<endl; break ; } // player 2's turn cout<< "Player 2 is 'O': choose the row and column " <<endl; cout<< "Row : " ; cin>>i; cout<< "Coumn : " ; cin>>j; for (;i>3 || i<1 || j>3 || j<1 || ( 'X' ==matrix[i-1][j-1] || 'O' ==matrix[i-1][j-1]);) { cout<< "Sorry boy, but you gotta choose another place.\n" ;
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 88
cout<< "Row : " ; cin>>i; cout<< "Column : " ; cin>>j; } matrix[i-1][j-1]= 'O' ; sum++; //the play box playbox(); //Check if wins if (matrix[0][0]== 'O' && matrix[0][0]==matrix[1][1] && matrix[1][1]==matrix[ 2][2]) { if (matrix[2][0]== 'O' && matrix[2][0]==matrix[1][1] && matrix[1][1]==matrix[ 0][2]) { if (matrix[0][0]== 'O' && matrix[0][0]==matrix[1][0] && matrix[1][0]==matrix[ 2][0]) { if (matrix[0][1]== 'O' && matrix[0][1]==matrix[1][1] && matrix[1][1]==matrix[ 2][1]) { if (matrix[0][2]== 'O' && matrix[0][2]==matrix[1][2] && matrix[1][2]==matrix[ 2][2]) { if (matrix[0][0]== 'O' && matrix[0][0]==matrix[0][1] && matrix[0][1]==matrix[ 0][2]) { if (matrix[1][0]== 'O' && matrix[1][0]==matrix[1][1] && matrix[1][1]==matrix[ 1][2]) { if (matrix[2][0]== 'O' && matrix[2][0]==matrix[2][1] && matrix[2][1]==matrix[ 2][2]) { } cout<< "\nWould you like to play again??? (Y - N)\n" ; cin>>ch; } system( "PAUSE"); return 0; } } /****************************/ void playbox( void ) { //the play box cout<< "\n\t\t 1 2 3\n" <<endl; cout<< "\t\t 1 " <<matrix[0][0]<< " | " <<matrix[0][1]<< " | " <<matrix[0][2]; cout<< "\t\t ---|---|---\n" ; cout<< "\t\t 2 " <<matrix[1][0]<< " | " <<matrix[1][1]<< " | " <<matrix[1][2]; cout<< "\t\t ---|---|---\n" ; cout<< "\t\t 3 " <<matrix[2][0]<< " | " <<matrix[2][1]<< " | " <<matrix[2][2]; }
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 89
Responde a lo siguiente:
¿Por que este juego implementa arreglos?
¿Que tipo de arreglos usa este programa?
Este programa contiene errores de manera intencional. ¿Cuáles son?
¿Cuál es la solucion a los errores presentados?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 90
Ejercicio 30 – Estructuras Realiza el siguiente ejemplo de manejo de estructuras:
prog34_estruc.cpp
/* Prog34 - Ejemplo de estrucutras */ #include <stdio.h> struct datos { char nombre[20]; char apellido[20]; long int dni; }; struct tablapersonas { int numpersonas; struct datos persona[100]; }; void main() { int i; struct tablapersonas tabla; printf( "Numero de personas: " ); scanf( "%d" , &tabla.numpersonas ); for (i= 0; i< tabla.numpersonas; i++) { printf( "\nNombre: " ); gets( tabla.persona[i].nombre ); printf( "\nApellido: " ); gets( tabla.persona[i].apellido ); //printf( "\nRFC: " ); //scanf( "%ld", &tabla.persona[i].dni ); } // Ahora hay que realizar el codigo para imprimir l os resultados de la tabla }
Y una vez terminado, completalo, creando el codigo necesario para que imprima los resultados capturados que se almacenaron en la estructura de la tabla.
Responde a lo que se indica: ¿Cuál fue el código que escribiste para completar el programa?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 91
¿Qué es una estructura?
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 92
Practica/Ejercicio 1 – Zodiaco
Ahora teclea el siguiente programa que te dice el signo zodiacal de una persona. Este ya es un
ejercicio resuelto en donde veras algunas instrucciones nuevas para construir una funcion que
borre la pantalla.
El programa ademas, esta basado en instrucciones condicionales IF…ELSE.
prog36_zodiaco.cpp
/*Este programa muestra el signo zodiacal de una pe rsona. Para ello el usuario debe introducir únicamente el día y el mes de nacimiento y el programa determinará inmediatamente el signo zodiac al de la persona.*/ //muestra el signo zodiacal #include <STdio.h> #include <math.h> #include <windows.h> void clrscr() /*Creando funcion para limpiar pantalla.*/ { HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); COORD coord = {0, 0}; DWORD count; CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(hStdOut, &csbi); FillConsoleOutputCharacter(hStdOut, ' ' , csbi.dwSize.X * csbi.dwSize.Y, coord, &count); SetConsoleCursorPosition(hStdOut, coord); } void main() { int salir,saliryesno; salir=0; while (salir==0){ clrscr(); /*Llamando la funcion para limpiar pantalla.*/ short unsigned int m,d = 0; printf( "Introduzca su mes de nacimiento: " ); scanf( "%d" ,&m, "\n" ); while ((m > 12) || (m < 1)){ printf( "Introduzca su mes de nacimiento(DE 1 A 12): " ); scanf( "%d" ,&m, "\n" ); } if (m==1){ printf( "Introduzca su dia de nacimiento: " ); scanf( "%d" ,&d, "\n" ); while ( (d>31) || (d != (d)) ){ //!= esta sentencia es diferente de{ printf( "Introduzca dia(ENTRE 1 Y 31): " ); scanf( "%d" ,&d, "\n" ); } (d<=20) ? printf( "\nSu signo es CAPRICORNIO.\n\n" ):printf( "\nSu signo es ACUARIO.\n\n" );
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 93
} else { if (m==2){ printf( "Introduzca su dia de nacimiento: " ); scanf( "%d" ,&d, "\n" ); while ( (d>29) || (d != (d)) ){ printf( "Introduzca dia(ENTRE 1 Y 29): " ); scanf( "%d" ,&d, "\n" ); } (d<=19) ? printf( "\nSu signo es ACUARIO.\n\n" ):printf( "\nSu signo es PISCIS.\n\n" ); } else { if (m==3){ printf( "Introduzca su dia de nacimiento: " ); scanf( "%d" ,&d, "\n" ); while ( (d>31) || (d != (d)) ){ printf( "Introduzca dia(ENTRE 1 Y 31): " ); scanf( "%d" ,&d, "\n" ); } (d<=20) ? printf( "\nSu signo es PISCIS.\n\n" ):printf( "\nSu signo es ARIES.\n\n" ); } else { if (m==4){ printf( "Introduzca su dia de nacimiento: " ); scanf( "%d" ,&d, "\n" ); while ( (d>30) || (d!=(d)) ){ printf( "Introduzca dia(ENTRE 1 Y 31): " ); scanf( "%d" ,&d, "\n" ); } (d<=20) ? printf( "\nSu signo es ARIES.\n\n" ):printf( "\nSu signo es TAURO.\n\n" ); } else { if (m==5){ printf( "Introduzca su dia de nacimiento: " ); scanf( "%d" ,&d, "\n" ); while ( (d>31) || (d != (d)) ){ printf( "Introduzca dia(ENTRE 1 Y 31): " ); scanf( "%d" ,&d, "\n" ); } (d<=21) ? printf( "\nSu signo es TAURO.\n\n" ):printf( "\nSu signo es GEMINIS.\n\n" ); } else { if (m==6){ printf( "Introduzca su dia de nacimiento: " ); scanf( "%d" ,&d, "\n" ); while ( (d>30) || (d!=(d)) ){ printf( "Introduzca dia(ENTRE 1 Y 31): " ); scanf( "%d" ,&d, "\n" ); }
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 94
(d<=21) ? printf( "\nSu signo es GEMINIS.\n\n" ):printf( "\nSu signo es CANCER.\n\n" ); } else { if (m==7){ printf( "Introduzca su dia de nacimiento: " ); scanf( "%d" ,&d, "\n" ); while ( (d>31) || (d != (d)) ){ printf( "Introduzca dia(ENTRE 1 Y 31): " ); scanf( "%d" ,&d, "\n" ); } (d<=23) ? printf( "\nSu signo es CANCER.\n\n" ):printf( "\nSu signo es LEO.\n\n" ); } else { if (m==8){ printf( "Introduzca su dia de nacimiento: " ); scanf( "%d" ,&d, "\n" ); while ( (d>31) || (d != (d)) ){ printf( "Introduzca dia(ENTRE 1 Y 31): " ); scanf( "%d" ,&d, "\n" ); } (d<=23) ? printf( "\nSu signo es LEO.\n\n" ):printf( "\nSu signo es VIRGO.\n\n" ); } else { if (m==9){ printf( "Introduzca su dia de nacimiento: " ); scanf( "%d" ,&d, "\n" ); while ( (d>30) || (d!=(d)) ){ printf( "Introduzca dia(ENTRE 1 Y 31): " ); scanf( "%d" ,&d, "\n" ); } (d<=23) ? printf( "\nSu signo es LEO.\n\n" ):printf( "\nSu signo es LIBRA.\n\n" ); } else { if (m==10){ printf( "Introduzca su dia de nacimiento: " ); scanf( "%d" ,&d, "\n" ); while ( (d>31) || (d != (d)) ){ printf( "Introduzca dia(ENTRE 1 Y 31): " );
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 95
scanf( "%d" ,&d, "\n" ); } (d<=23) ? printf( "\nSu signo es LIBRA.\n\n" ) : printf( "\nSu signo es ESCORPION.\n\n" ); } else { if (m==11){ printf( "Introduzca su dia de nacimiento: " ); scanf( "%d" ,&d, "\n" ); while ( (d>30) || (d!=(d)) ){ printf( "Introduzca dia(ENTRE 1 Y 31): " ); scanf( "%d" ,&d, "\n" ); } (d<=22) ? printf( "\nSu signo es ESCORPION.\n\n" ):printf( "\nSu signo es SAGITARIO.\n\n" ); } else { if (m==12){ printf( "Introduzca su dia de nacimiento: " ); scanf( "%d" ,&d, "\n" ); while ( (d>31) || (d !=(d)) ){ printf( "Introduzca dia(ENTRE 1 Y 31): " ); scanf( "%d" ,&d, "\n" ); } (d<=21) ? printf( "\nSu signo es SAGITARIO.\n\n" ):printf( "\nSu signo es CAPRICORNIO.\n\n" ); } } } } } } } } } } } } printf( "SI DESEA SALIR PRESIONE 1 O DE LO CONTRARIO PRESIO NE OTRO NUMERO: "); scanf( "%d" ,&saliryesno);
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 96
if (saliryesno==1){ salir=1; } } }
ACTIVIDAD
Realiza el mismo programa pero usando sentencias SWITCH y una modificacion para hacer el
algoritmo mas simple.
Practica/Ejercicio 2 – Califaciones Estilo USA
Este ejercicio permite convertir el sistema de calificacion escolar de Mexico al sistema de Estados
Unidos que se basa en letras de la A hasta la F. Primero se debe mostrar una tabla de equivalencias
y luego preguntara la calificacion. El resultado sera el equivalente a la notacion americana.
Generalmente, para este tipo de programas se utilizan muchas condicionales. Este tipo de
programas se utilizan en el ambito escolar para saber las calificaciones de los alumnos.
prog37_califeu.cpp
/*El programa muestra primero una tabla de notas co n sus equivalentes en el Standard Grading System o el sistema utilizado e n los Estados Unidos que va desde la A hasta la F. El programa pregunta rá al usuario su nota y transformará ese resultado al equivalente en el S tandard Grading System. También el programa dará una pequeña pero valiosa recomendación al usuario respecto a su nivel de estudio y calidad como estudiante.*/ #include "stdio.h" #include <windows.h> void clrscr() /*Creando funcion para limpiar pantalla.*/ { HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); COORD coord = {0, 0}; DWORD count; CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(hStdOut, &csbi); FillConsoleOutputCharacter(hStdOut, ' ' , csbi.dwSize.X * csbi.dwSize.Y, coord, &count); SetConsoleCursorPosition(hStdOut, coord); } void main() { int salir,saliryesno; salir=0; while (salir==0){ clrscr(); /*Llamando la funcion para limpiar pantalla.*/ int a; float nota; printf( "\n\t\t\tNOTAS\t\tEQUIVALENTE\n" );
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 97
printf( "\t\t 9.0 - 10.0\t\t A\n" ); printf( "\t\t 8.5 - 8.9\t\t B+\n" ); printf( "\t\t 8.0 - 8.4\t\t B\n" ); printf( "\t\t 7.5 - 7.9\t\t C+\n" ); printf( "\t\t 7.0 - 7.4\t\t C\n" ); printf( "\t\t 6.0 - 6.9\t\t D\n" ); printf( "\t\t 0.0 - 6.0\t\t F\n" ); a=0; while (a==0){ printf( "\nIntroduzca su nota en Programacion II: " ); scanf( "%f" ,¬a); if (nota<0 || nota>10){ /*a sigue valiendo cero y no se sale del ciclo*/ } else { a=1; } } if (nota>=9){ printf( "\nNOTA EQUIVALENTE EN STANDARD GRADING SYSTEM: A\n" ); printf( "RECOMENDACIONES: Excelente, si continua asi usted es un genio.\n\n" ); } else { if (nota>=8.5){ printf( "\nNOTA EQUIVALENTE EN STANDARD GRADING SYSTEM: B+\n" ); printf( "RECOMENDACIONES: Muy bien, su nivel es impresionante.\n\n" ); } else { if (nota>=8){ printf( "\nNOTA EQUIVALENTE EN STANDARD GRADING SYSTEM: B\n" ); printf( "RECOMENDACIONES: Bien, su nivel es muy bueno.\n\n" ); } else { if (nota>=7.5){ printf( "\nNOTA EQUIVALENTE EN STANDARD GRADING SYSTEM: C+\n" ); printf( "RECOMENDACIONES: Usted esta dentro del promedio, trate de no bajar.\n\n" ); } else { if (nota>=7){ printf( "\nNOTA EQUIVALENTE EN STANDARD GRADING SYSTEM: C\n"); printf( "RECOMENDACIONES: Usted la va pasando, pero trate elevar su promedio.\n\n" ); } else { if (nota>=6){ printf( "\nNOTA EQUIVALENTE EN STANDARD GRADING SYSTEM: D\n" ); printf( "RECOMENDACIONES: Usted esta en la cuerda floja, un pequeno descuido \nlo pone en problemas.\n\n" ); } else { /*nota mayor que cero pero
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 98
menor que 6.*/ printf( "\nNOTA EQUIVALENTE EN STANDARD GRADING SYSTEM: F\n" ); printf( "RECOMENDACIONES: Su nota sinceramente es mala, busque nuevas \ntecni cas de estudio.\n\n" ); } } } } } } printf( "SI DESEA SALIR PRESIONE 1 O DE LO CONTRARIO PRESIO NE OTRO NUMERO: "); scanf( "%d" ,&saliryesno); if (saliryesno==1){ salir=1; } } }
ACTIVIDAD
Realiza el mismo programa, cambiando las sentencias condicionales IF..ELSE por SWITCH para hacer
el programa mas corto.
Tambien podrias usar un archivo externo para leer la informacion de equivalencias o la informacion
de calificaciones de un alumno.
Practica/Ejercicio 3 – Sueldos a trabajador
En este ejercicio deberas realizar un programa que calcule el pago que recibe un trabajador en base
a las horas del dia en que trabaja. El ejercicio ya esta escrito por lo que deberas leer y entender los
comentarios al principio, asi como la logica de construccion.
Este tipo de programas se usa mucho en sistemas administrativos de nominas o recursos humanos
prog38_sueldos.cpp
/*Este programa muestra los pagos que recibirá un t rabajador por cada hora laboral en base a la hora del día en que trabaja. El usuario deberá escribir el número de horas trabajadas en cada uno de los ho rarios y el programa determinará el total de dinero a recibir por el tra bajador y también dirá si ganó más dinero por horas extras que por horas de o ficina trabajadas o viceversa, o si el trabajador ganó exáctamente lo m ismo por horas extras que por horas de oficina.*/ #include "STdio.h" #include <windows.h> void clrscr() /*Creando funcion para limpiar pantalla.*/ { HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); COORD coord = {0, 0}; DWORD count; CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(hStdOut, &csbi);
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 99
FillConsoleOutputCharacter(hStdOut, ' ' , csbi.dwSize.X * csbi.dwSize.Y, coord, &count); SetConsoleCursorPosition(hStdOut, coord); } void main() { int salir,saliryesno; salir=0; while (salir==0){ clrscr(); /*Llamando la funcion para limpiar pantalla.*/ printf( "\n\t\tHORARIO\t\t\t PAGO \n\n" ); printf( "\t 8:00 AM - 4:00 PM\t\tPAGO BASE\n" ); printf( "\t 4:00 PM - 8:00 PM\t 25 POR CIENTO EXTRA\n" ); printf( "\t 8:00 PM - 12:00 AM\t 50 POR CIENTO EXTRA\n" ); printf( "\t 12:00 AM - 8:00 AM\t\tPAGO DOBLE\n\n" ); int horas_trab,horas_trab25,horas_trab50,horas_doble; float pago_base,pago_extra25,pago_extra50,pago_doble,suma _extra,suma_base,pago,sueldo_total,pago_extra; printf( "SUELDO BASE POR HORA TRABAJADA: " ); scanf( "%f" ,&pago); printf( "\nNumero de horas trabajadas de 8:00 am a 4:00 pm: " ); scanf( "%d" ,&horas_trab); pago_base=(horas_trab*pago); printf( "Numero de horas trabajadas de 4:00 pm a 8:00 pm: " ); scanf( "%d" ,&horas_trab25); pago_extra25=(horas_trab25*(1.25)*pago); printf( "Numero de horas trabajadas de 8:00 pm a 12:00 am: " ); scanf( "%d" ,&horas_trab50); pago_extra50=(horas_trab50*(1.50)*pago); printf( "Numero de horas trabajadas de 12:00 am a 8:00am: " ); scanf( "%d" ,&horas_doble); pago_doble=(horas_doble*(2.0)*pago); suma_base=pago*horas_trab; suma_extra=(pago_extra25+pago_extra50+pago_doble) ; sueldo_total= suma_extra+pago_base; printf( "\nEL PAGO TOTAL QUE RECIBIRA EL TRABAJADOR ES: $%.2f\n\n" ,sueldo_total); printf( "EL SALARIO DEL TRABAJADOR POR HORAS DE OFICINA ES: $%.2f\n" ,suma_base); printf( "EL SALARIO DEL TRABAJADOR POR HORAS EXTRAS ES: $%.2f\n" ,suma_extra); if (suma_extra>suma_base){ printf( "\nEL TRABAJADOR GANO MAS DINERO POR HORAS EXTRAS QUE POR HORAS DE OFICINA\n\n" ); } else { if (suma_extra==suma_base){ printf( "EL TRABAJADOR GANO EL MISMO SALARIO POR HORAS EXTRAS QUE POR HORAS DE OFICINA\n\n" ); } else { /*pago_base es mayor que suma_extra*/ printf( "EL TRABAJADOR GANO MAS DINERO POR HORAS DE OFICINA QUE POR HORAS EXTRA\n\n" ); } } printf( "SI DESEA SALIR PRESIONE 1 O DE LO CONTRARIO PRESIO NE OTRO NUMERO: "); scanf( "%d" ,&saliryesno); if (saliryesno==1){
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 100
salir=1; } } }
ACTIVIDAD:
Realiza el diagrama de flujo de este programa
Practica/Ejercicio 4 – Promocion de Ventas
El siguiente programa hara una promocion de ventas a un cliente en una tienda. De tal forma, que
de manera aleatoria le tocara una bola de un color y dicho color tendra asociado un descuento para
los productos que compre.
Es un interesante ejemplo para ver nuevamente la funcion aleatoria, manejo de tablas,
condicionales. Este tipo de programa es util en el area de ventas de un negocio.
prog39_promocion.cpp
/*Este programa pide primeramente la cantidad total de compras de una persona. Si la cantidad es inferior a $100.00, el programa dirá que el cliente no aplica a la promoción. Pero si la perso na ingresa una cantidad en compras igual o superior a $100.00, el programa genera de forma aleatoria un número entero del cero al cinco. Cada número corresponderá a un color diferente de cinco colores de bolas que hay para determinar el descuento que el cliente recibirá com o premio. Si la bola aleatoria es color blanco, no hay descuento, pero s i es uno de los otros cuatro colores, sí se aplicará un descuento determi nado según la tabla que aparecerá, y ese descuento se aplicará sobre el total de la compra que introdujo inicialmente el usuario, de manera qu e el programa mostrará un nuevo valor a pagar luego de haber aplicado el d escuento.*/ #include <stdio.h> #include <stdlib.h> #include <time.h> #include <windows.h> void clrscr() /*Creando funcion para limpiar pantalla.*/ { HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); COORD coord = {0, 0}; DWORD count; CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(hStdOut, &csbi); FillConsoleOutputCharacter(hStdOut, ' ' , csbi.dwSize.X * csbi.dwSize.Y, coord, &count); SetConsoleCursorPosition(hStdOut, coord); } void main() {
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 101
int salir,saliryesno; salir=0; while (salir==0){ clrscr(); /*Llamando la funcion para limpiar pantalla.*/ int random; float gasto, ncargo; printf( "\nINTRODUZCA LA CANTIDAD TOTAL DE LA COMPRA: " ); scanf( "%f" ,&gasto, "\n" ); while (gasto < 0) { printf( "NO EXISTEN CARGOS NEGATIVOS INTRODUZCA NUEVO GASTO: " ); scanf( "%f" ,&gasto, "\n" ); } if (gasto >= 100) { printf( "\nSU GASTO IGUALA O SUPERA LOS $100.00 Y POR TANTO PARTICIPA EN LA PROMOCION.\n" ); printf( "\n\t\t COLOR\t\t DESCUENTO\n\n" ); printf( "\t\tBOLA BLANCA\t\t NO TIENE\n" ); printf( "\t\tBOLA ROJA\t\t10 POR CIENTO\n" ); printf( "\t\tBOLA AZUL\t\t20 POR CIENTO\n" ); printf( "\t\tBOLA VERDE\t\t25 POR CIENTO\n" ); printf( "\t\tBOLA AMARILLA\t\t50 POR CIENTO\n\n" ); srand(time(NULL)); /*Inicializa el generador random*/ random=rand()%5; /*Genera los números random*/ if (random==0){ printf( "ALEATORIAMENTE USTED OBTUVO UNA BOLA BLANCA\n\n" ); printf( "LO SENTIMOS, NO HA GANADO NINGUN DESCUENTO."); printf( " EL TOTAL A PAGAR ES DE $%.2f\n\n" ,gasto); } else { if (random==1){ printf( "ALEATORIAMENTE USTED OBTUVO UNA BOLA ROJA\n\n" ); printf( "FELIDADES, HA GANADO UN 10 POR CIENTO DE DESCUENTO \n\n" ); ncargo=gasto-(gasto*0.1); printf( "SU NUEVO TOTAL A PAGAR ES: $%.2f\n\n" , ncargo, "\n\n" ); } else { if (random==2){ printf( "ALEATORIAMENTE USTED OBTUVO UNA BOLA AZUL\n\n" ); printf( "FELIDADES, HA GANADO UN 20 POR CIENTO DE DESCUENTO \n\n" ); ncargo=gasto-(gasto*0.2); printf( "SU NUEVO TOTAL A PAGAR ES: $%.2f\n\n" , ncargo, "\n\n" ); } else {
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 102
if (random==3){ printf( "ALEATORIAMENTE USTED OBTUVO UNA BOLA VERDE\n\n" ); printf( "FELIDADES, HA GANADO UN 25 POR CIENTO DE DESCUENTO \n\n" ); ncargo=gasto-(gasto*0.25); printf( "SU NUEVO TOTAL A PAGAR ES: $%.2f\n\n" , ncargo, "\n\n" ); } else { if (random==4){ printf( "ALEATORIAMENTE USTED OBTUVO UNA BOLA AMARILLA\n\n" ); printf( "FELIDADES, HA GANADO UN 50 POR CIENTO DE DESCUENTO \n\n" ); ncargo=gasto-(gasto*0.5); printf( "SU NUEVO TOTAL A PAGAR ES: $%.2f\n\n" , ncargo, "\n\n" ); } } } } } } else { /*El gasto es menor a $100.00*/ printf( "\n\nLO SENTIMOS, SU GASTO ES MENOR A CIEN DOLARES Y NO APLICA A LA PROMOCION.\n\n" ); } printf( "SI DESEA SALIR PRESIONE 1 O DE LO CONTRARIO PRESIO NE OTRO NUMERO: "); scanf( "%d" ,&saliryesno); if (saliryesno==1){ salir=1; } } }
ACTIVIDAD
Realiza el mismo programa pero usando las sentencias SWITCH donde se requiera
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 103
Practica/Ejercicio 5 – Retraso en renta peliculas
La siguiente practica es para elaborar un programa que se usaria en un videoclub. Este mostrara un
listado de peliculas y luego se pedira el numero de dias de atraso de una pelicula. El programa
calculara el monto a pagar, según el precio de la pelicula y la tabla de recargos.
prog40_peliculas.cpp
/*Este programa muestra primero el listado de categ oria de peliculas y pide al usuario que introduzca el codigo de la cate goria de la pelicula y posterior a ello pide que el usuario introduzca el número de días de atraso en la devolución de la película. Lo que hac e el programa es sumar el precio de la película más el valor del recargo m ultiplicado por el número de días de atraso, y así se muestra al final el total a pagar.*/ #include "STdio.h" #include <windows.h> void clrscr() /*Creando funcion para limpiar pantalla.*/ { HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); COORD coord = {0, 0}; DWORD count; CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(hStdOut, &csbi); FillConsoleOutputCharacter(hStdOut, ' ' , csbi.dwSize.X * csbi.dwSize.Y, coord, &count); SetConsoleCursorPosition(hStdOut, coord); } void main() { int salir,saliryesno; salir=0; while (salir==0){ clrscr(); /*Llamando la funcion para limpiar pantalla.*/ int cod_pel,a; float dias,fav,nue,est,sest; printf( "\n" ); printf( "\t CATEGORIA\tPRECIO\t CODIGO\tRECARGO/DIA D E ATRASO\n\n" ); printf( "\tFAVORITOS\t$2.50\t\t1\t\t$0.50\n" ); printf( "\tNUEVOS\t\t$3.00\t\t2\t\t$0.75\n" ); printf( "\tESTRENOS\t$3.50\t\t3\t\t$1.00\n" ); printf( "\tSUPER ESTRENOS\t$4.00\t\t4\t\t$1.50\n\n" ); printf( "INTRODUZCA EL CODIGO DE LA CATEGORIA DE LA PELICUL A: " ); scanf( "%d" ,&cod_pel); a=0; while (a==0){ if (cod_pel<1 || cod_pel>4){ printf( "INTRODUZCA EL CODIGO DE LA CATEGORIA DE LA PELICULA (ENTRE 1 Y 4): " );
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 104
scanf( "%d" ,&cod_pel); } else { a=1; } } printf( "INTRODUZCA EL NUMERO DE DIAS DE ATRASO EN LA DEVOLUCION: " ); scanf( "%f" ,&dias); a=0; while (a==0){ if (dias<0){ printf( "INTRODUZCA EL NUMERO DE DIAS DE ATRASO EN LA DEVOLUCION: " ); scanf( "%f" ,&dias); } else { a=1; } } switch (cod_pel) { case 1: fav=((dias*0.5)+2.5); printf( "\nEL TOTAL A PAGAR ES: $%.2f\n\n" ,fav); break ; case 2: nue=((dias*0.75)+3); printf( "\nEL TOTAL A PAGAR ES: $%.2f\n\n" ,nue); break ; case 3: est= ((dias*1.00)+3.5); printf( "\nEL TOTAL A PAGAR ES: $%.2f\n\n" ,est); break ; case 4: sest=((dias*1.5)+4.0); printf( "\nEL TOTAL A PAGAR ES: $%.2f dolares\n\n" ,sest); break ; } printf( "SI DESEA SALIR PRESIONE 1 O DE LO CONTRARIO PRESIO NE OTRO NUMERO: "); scanf( "%d" ,&saliryesno); switch (saliryesno){ case 1: salir=1; } } }
ACTIVIDAD
Elimina el codigo que no sea necesario y que puedas sustituir por otras funciones o crear las propias
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 105
Practica/Ejercicio 6 – Dados
Otra practica de programa para ver la funcion aleatoria. Tambien repasamos las sentencias IF…ELSE
prog41_dados.cpp
/* DISELE UN PROGRAMA QUE SIMULE EL LANZAMIENTO DE DOS DADOS HASTA QUE SALGA UN SIETE DOS VECES CONSECUTIVAS EL PROGRAMA DEBE INDICAR EN QUE TIRADA OCURRIO ESE RESULTADO Este programa es posible gracias a la utilizacion d el generador de numeros aleatorios para simular el lanzamiento de d os dados El programa indica en que tirada se da el evento de los dos dados que caigan 7 consecutivamente. Para lograr esto se da la condicion ("if") que cada vez que caiga un 7 que vaya a evaluar si la siguiente tirada da otro s iete. Si esto es asi, el programa se sale del ciclo o de lo contrario continua. Se añade tambien un contador que es el que dice fin almente a las cuantas tiradas se dio el eento de dos sietes consecutivame nte*/ #include <stdio.h> #include <time.h> #include <windows.h> #define FONDO (0) #define VERDE (10) #define AMARILLO (14) void main() { HANDLE hStdInput=INVALID_HANDLE_VALUE, hStdOutput=INVALID_HANDLE_VALUE; hStdInput=GetStdHandle(STD_INPUT_HANDLE); hStdOutput=GetStdHandle(STD_OUTPUT_HANDLE); SetConsoleTextAttribute(hStdOutput,FONDO|AMARILLO) ; float salir; int saliryesno; salir=0; while (salir==0) { system( "cls" ); SetConsoleTextAttribute(hStdOutput, FONDO|VERDE); printf( "\n\t\t\t EJERCICIO 41 (DADOS)\n" ); printf( "\t\t\t =====================\n" ); int a, lanzamiento, i=0, contador=0; printf( "\nPROBLEMA: DISEÑE UN PROGRAMA QUE SIMULE UN LANZAMIENTO DE DOS DADOS HASTA QUE\n"); printf( "SALGA UN SIETE DOS VECES CONSECUTIVAS. EL PROGRAMA DEBE INDICAR EN QUE TIRADA\n" ); printf( "OCURRIO ESE RESULTADO.\n\n" ); srand(time(NULL)); //Inicializar generador aleatorio while (i==0){ lanzamiento=1+rand()%12; //Generar numeros aleatorios
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 106
if (lanzamiento==7){ lanzamiento=1+rand()%12; contador=contador+1; if (lanzamiento==7){ contador=contador+1; i=1; } } contador=contador+1; } printf( "EL SIETE SALIO DOS VECES CONSECUTIVAS EN LA TIRADA NUMERO %d.\n\n" ,contador); SetConsoleTextAttribute(hStdOutput, FONDO|AMARILL O); printf( "SI DESEA SALIR PRESIONE 1 O DE LO CONTRARIO PRESIO NE OTRO NUMERO: "); scanf( "%d" , &saliryesno); if (saliryesno==1){ printf( "\n\a" ); salir=1; } } //Fin del while }
ACTIVIDAD
Trata de modificar el programa para que en lugar de un dado, sea una moneda (recuerda que tiene
2 lados).
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 107
PARTE IV
PRACTICAS PARA DESARROLLAR
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 108
PRACTICA 7 – Contando dinero
Desarrolla un programa que ira preguntando por la cantidad de billetes y monedas de cada valor
que tiene el usuario y luego determinara la suma de dinero que hay en monedas y la suma que hay
en billetes. El programa dira la suma total de dinero que tiene. Finalmente el programa dara al
usuario la posibiliad de transformar la cantidad de la moneda local a dolares o euros según decida
el usuario.
PRACTICA 8 – Numeros
Desarrolla un programa donde el usuario introduzca tres numeros enteros y luego nos indique cual
de ellos es el central o el de en medio.
PRACTICA 9 – Numeros ordenados
Crea un programa donde el usuario introduzca tres numeros enteros y se orden de manera
ascendete y a continuacion en orden descendente.
PRACTICA 10 – Boletos
Desarrolla un programa que nos diga el precio de un boleto de ida y vuelta en autobus, conociendo
la distancia a recorrer y sabiendo que si el numero de dias de estancia es mayor o igual a 7, y la
distancia mayor o igual a 100 kilometros, el boleto tiene un descuento del 50%
PRACTICA 11 – Conversiones metricas
Crea un programa que muestre un listado de unidades de medida y que pida al usuario indicar con
cual desea trabajar. Despues, se le pide que introduzca el valor de la unidad que selecciono y
entonces el programa le dice el equivalente de ese valor en todas las otras unidades de medida. La
transformacion a equivalencia se hace entre estas cuatro unidades: metros, pulgadas, pies y yardas.
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 109
PRACTICAS DE VARIABLES, TIPOS DE DATOS, ASIGNACIONES,
OPERADORES
PRACTICA 12 – Rectangulo
Haga un programa que halle el area y el perimetro de un rectangulo. Considere las siguientes
formulas: area = base * altura, perimetro = 2 * (base + altura).
PRACTICA 13 – Pies
Diseñe un programa para convertir una longitud dada en centimetros a pies. Considere que: 1 pie =
30.48 centimetros.
PRACTICA 14 – Triangulo
Calcular el area de un triangulo, conociendo su altura y su base.
PRACTICA 15 – Raices
Realizar un programa para ingresarle los coeficientes A, B y C de una ecuacion de segundo grado, y
que calcule y muestre por pantalla las raices X1 y X2. X1 = (-B + SQR(B^2 – 4*A*C)) / (2*A) y X2 = (-B
– SQR(B^2 – 4*A*C)) / (2*A). Las raices de una ecuacion de segundo orden, pueden ser raices reales
o imaginarias. Para este programa asuma que las raices son siempre reales.
PRACTICA 16 – Tiempos
Diseñe un programa para sumar dos marcas de tiempo dadas en horas, minutos y segundos.
PRACTICA 17 – Prestamo
Se solicita un prestamo por C pesos durante N meses a una tasa de interes mensual L. Al final de los
N meses la cantidad adeudada es C * (1 +I) ^N. Hacer un programa al cual se le dan los valores de C,
N e L, y calcule e imprima la suma adeudada.
PRACTICA 18 – Metros
Hacer un programa para ingresarle una medida en metros, y que imprima esa medida expresada en
centimetros, pulgadas, pies y yardas. Los factores de conversion son los siguientes:
1 yarda = 3 pies
1 pie = 12 pulgadas
1 metro = 100 centimetros
1 pulgada = 2.54 centimetros
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 110
PRACTICA 19 – Millonario
Un millonario excentrico tenia tres hijos: Carlos, Jose y Marta. Al morir dejo el siguiente legado: A
jose le dejo 4/3 de lo que le dejo Carlos. A Carlos le dejo 1/3 de su fortuna. A marta le dejo la mitad
de lo que le dejo a Jose. Preparar un programa para darle la suma a repartir e imprima cuanto le
toco a cada uno.
PRACTICA 20 – Promedio
Haga un programa para calcular el promedio de cinco calificaciones.
PRACTICA 21 – Circulo
Escribe un programa en C++ que calcule el area y perimetro de un circulo
PRACTICA 22 – Maquina reversadora de numeros
Haz un programa que reciba un numero de 5 digitos (suponga que lo ingresan bien) y muestre el
numero en forma inversa.
PRACTICA 23 – Nibles
Haga un programa que sume los nibles (4 bits) mas significativo y menos significativo de una
variable de un byte llamada dato y escriba el resultado en una variable de un byte llamada resul.
PRACTICA 24 – Multiplicacion por 300
Haga un programa que lea un entero y lo multiplique por 300. El uso del operador “*” y “\” esta
prohibido.
PRACTICA 25 – Peso
Dado el peso de una persona en libras, calcule su peso en kilogramos. NOTA: 1 libra es
aproximadamente igual a 0.453592Kg.
PRACTICA 26 – Fahrenheit
Haga un programa para convertir una temperatura en grados Centigrados a Fahrenheit. La formula
para hacer la conversion es: Fahrenheit = (9 * Celsius) / 5 + 32.
PRACTICA 27 – Celsius
Haga un programa para convertir una temperatura en grados Fahrenheit a grados Celsius. Utilizar la
formula: Celsius = (5/9)*(Fahrenheit-32).
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 111
PRACTICA 28 – Determinante
Dada una matriz de tres filas por tres columnas:
| A1 A2 A3 |
| A4 A5 A6 |
| A7 A8 A9 |
Puede obtenerse su determinante mediante la formula:
D = A1*A5*A9 + A2*A6*A7 + A3*A4*A8 – A3*A5*A7 – A2*A4*A9 – A1*A6*A8
Preparar un programa que permita ingresar por teclado los elementos de la matriz, y que calcule y
muestre por pantalla el determinante.
PRACTICA 29 – Don Manolo
El almacen “Don Manolo”, necesita un programa que ayude a calcular la forma de dar el cambio a
sus clientes con el minimo de billetes y monedas posible.
PRACTICA 30 - ISBN
El International Standard Book Number (en español Número Internacional Estándar del Libro), o
ISBN (pronunciado a veces como "is-bin"), es un identificador único para libros. El número tiene
siempre 10 dígitos de longitud, y está dividido en cuatro partes:
1. El código del país o lengua de origen
2. El editor
3. El número del artículo, y
4. El dígito de control.
Estas partes tienen distintas longitudes y generalmente están separadas por guiones. El dígito de
control de un ISBN se puede calcular multiplicando cada dígito del ISBN por el lugar que ocupa
dicho dígito en la secuencia numérica (multiplicando el primero por la izquierda por 1, el siguiente
por 2, etc.) Tomando después la suma de las multiplicaciones y calculando el modulo 11 de esta
suma, con 10 representado por el carácter "X". Por ejemplo, para calcular el dígito de control de un
ISBN cuyos nueve primeros dígitos son 0-306-40615:
1x0 + 2x3 + 3x0 + 4x6 + 5x4 + 6x0 + 7x6 + 8x1 + 9x5
= 0 + 6 + 0 + 24 + 20 + 0 + 42 + 8 + 45
= 145
= 145%11 = 2
Por lo que el dígito de control es 2, y la secuencia completa es ISBN 0-306-40615-2. Escriba un
programa que, a partir de los dígitos de un ISBN, calcule el dígito de control.
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 112
PRACTICA 31 – Odometer
A sales person leaves his home every Monday and returns every Friday. He travels by company car.
Each day on the road, the salesperson records the amount of gasoline put in the car. Given the
starting odometer reading(that is, the odometer reading before he leaves on monday) and the
ending odometer reading (the odometer reading after he returns home on friday). here some
sample data:
start: 68723
end: 71289
Mon: 15.75
Tues: 16.30
Wed: 10.95
Thru: 20.65
Fri: 30.00
Find how many miles could the saleperson drive (in average) with a galon.
PRACTICA 32 – Triangulo II
Suponga que a, b y c son las longitudes de los lados de un triángulo. Entonces el área de un
triángulo se puede calcular utilizando la siguiente formula: área = SQR( s(s-a)(s-b)(s-c) ). Donde s es
el semi-perímetro (a+b+c)/2.
PRACTICA 33 – Distancia Euclidiana
Haga un programa que pregunte por las coordenadas de dos puntos en el plano y calcule la
distancia (euclidiana) entre ellos. La distancia entre dos puntos (x1, y1) y (x2, y2) esta dada por la
formula d=SQR( (x2-x1)^2 + (y2-y1)^2 ).
PRACTICA 34 – Validacion de Tarjetas de credito
Todas las tarjetas de crédito tienen un sistema de verificación de números. Esto se hace para
verificar la autenticidad del número de la tarjeta. Cada número tiene un significado. La mayoría de
las veces los primeros números agrupados (que suelen ser de cuatro) significan el tipo de tarjeta.
Los demás números significan la oficina del representante de servicio y los números que identifican
al cliente. Los dos últimos números se utilizan para verificar si el número de tarjeta de crédito es
correcto. A estos se le conocen como los check digits. Construya un programa que dada la siguiente
fórmula valide los números de tarjeta de crédito.
1. Los números en posiciones pares se acumulan.
2. Cada número en posicion impares se multiplica por 2 y se acumula.
3. Los check digits se calculan buscando el residuo de lo acumulado de números en posiciones pares
entre el acumulado de números en posiciones impares.
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 113
PRACTICA 35 – Suma de fracciones
Para sumar dos números racionales se utiliza la siguiente fórmula:
a c ad + bc
- + - = -------
b d bd
Haga un programa que calcule la suma entre dos fracciones.
PRACTICAS DE ESTRUCTURAS DE CONTROL
PRACTICA 36 – Max
Calcular el máximo de dos números.
PRACTICA 37 – Positivo Negativo
Escribir un programa que indique si un número introducido por teclado es positivo, igual a cero o
negativo.
PRACITCA 38 – Par Impar
Escribir un programa que indique si un número introducido por teclado es par o impar.
PRACTICA 39 – Convertidor de divisas
Hacer un programa que me permita convertir una cierta cantidad de Pesos Colombiano en otras
divisas. Las divisas que puede manejar su programa son:
1 Euro = 2,679.50 Pesos Colombianos
1 Yen Japones = 19.17 Pesos Colombianos
1 Peso Chileno = 4.23 Pesos Colombianos
1 Libra Esterlina = 3,921.88 Pesos Colombianos
1 Dólar Americano = 2,253.00 Pesos Colombianos
1 Dólar Australiano = 734.18 Pesos Colombianos
1 Dólar Canadiense = 1,948.77 Pesos Colombianos
[Nota] Haga uso del comando switch para desplegar el menú
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 114
PRACTICA 40 – Grado Promedio
Hacer un programa que lea tres grados en letras, y muestre su promedio. El programa deberá
utilizar una escala de 4 puntos para calcular el promedio numérico (PN): 4 para A, 3 para B, 2 para
C, 1 para D y 0 para F. Su programa debe mostrar que el promedio es A si PN es mayor a 3.5, B si es
mayor a 2.5, C si es mayor a 1.5, D si es mayor a 0.5 o F de lo contrario. [Nota] Por simplicidad,
asuma que el programa solo acepta letras mayúsculas.
PRACTICA 41 – Bisiesto
Haga un programa que determine si un año es bisiesto: si es divisible por 4, pero no es divisible por
100 o si es divisible por 400.
PRACTICA 42 – Diferencia
Ingresar tres números y hallar la diferencia del mayor menos el menor.
PRACTICA 43 – Saludo
Escriba un programa que lea un instante de tiempo expresado en horas y minutos y escriba como
respuesta uno de los mensajes "Buenos das", "Buenas tardes" o "Buenas noches", de acuerdo con
las siguientes reglas:
1. Se considera que es de día desde las 6:00 horas hasta las 11:59 horas.
2. Se considera que es por la tarde desde las 12:00 horas hasta las 19:00 horas.
3. Se considera que es de noche desde las 19:01 horas hasta las 5:59 horas
PRACTICA 44 - Control
Escriba un programa que lea un número x del teclado y lleve a cabo las siguientes operaciones:
a) si es positivo, calcular e imprimir su raíz cuadrada.
b) si es distinto de cero, calcular e imprimir su inverso (1/x).
c) si es cuadrado perfecto (tiene raíz cuadrada exacta), imprimir el mensaje "Es un cuadrado
perfecto".
d) si es par, calcular e imprimir su cociente entre 2 (x/2).
e) si es positivo y menor que 10, imprimir el mensaje "Sólo tiene un dígito".
f) si está comprendido entre 32 y 127 (ambos inclusive) imprimir el carácter cuyo código ASCII
representa.
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 115
PRACTICA 45 – Multiplo
Ingresar un número n y verificar si es múltiplo de 3 o 5.
PRACTICA 46 – ASCII
Lea un carácter y deduzca si es vocal, consonante, dígito o caracter especial.
PRACTICA 47 – Super Raices
Partiendo del enunciado del problema [Raíces] arriba mencionado, tener en cuenta la posiblidad de
tener raíces negativas. Primero calcule el discriminate B^2 - 4*A*C, si el discriminante es > 0.0, las
dos raíces son reales y distintas y se caculan de la misma manera que en el programa [Raíces], si el
discriminante es 0, las dos raices son reales e iguales y valen X1 = X2 = -B / (2*A). Finalmente, si el
discriminante es < 0.0, las dos raíces son complejas conjugadas y valen
X1_parte_real=X2_parte_real=-B / (2*A), X1_parte_imaginaria = SQR(-discriminante)/(2*A) y
X2_parte_imaginaria = -SQR(-discriminante)/(2*A).
PRACTICA 48 – Dia semana
Se desea escribir el nombre del día de la semana en función de un número de día, introducido por
teclado. Donde 1 es Domingo, 2 Lunes y así sucesivamente.
PRACTICA 49 – Super Triangulo
Diseñe un programa que lea tres longitudes y determine si forman o no un triángulo. Si es un
triángulo determine de que tipo de triángulo se trata entre: equilátero (si tiene tres lados iguales),
isósceles (si tiene dos lados iguales) o escaleno (si tiene tres lados desiguales). Considere que para
formar un triángulo se requiere que: "el lado mayor sea menor que la suma de los otros dos lados".
PRACTICAS DE ESTRUCTURAS REPETITIVAS
PRACTICA 50 – Countdown
Haga un programa que haga un conteo regresivo desde n hasta 1, donde n es un número entero
positivo.
PRACTICA 51 – Factorial
El factorial de un número es el producto de todos los números entre 1 y ese número. Por ejemplo,
el factorial de 4 es 4x3x2x1 = 24. Haga un programa para calcular el factorial de un número n.
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 116
PRACTICA 52 – Serie 1
Elabore un programa que calcule e imprima la suma de 1 + 1/2 + 1/3+ 1/4 + 1/5 + 1/6 + . . . + 1/50.
PRACTICA 53 – Primo
Por si no lo recurda, los números primos son cantidades enteras positivas que únicamente pueden
dividirse por uno o por sí mismos. Hacer un programa que detecte si un número es primo o no.
Nota: Para saber si un número n es primo, hay que comprobar que el número no sea divisible por
ningún entero entre 2 y la raíz cuadrada del propio número.
PRACTICA 54 – Ingenieros 2050
Estime la población de Ingenieros en sistemas en Mexico para el año 2050, considerando un
crecimiento anual de 11%. Actualmente hay 40000 profesionales del área.
PRACTICA 55 – Super Primos
Haga un programa que imprima todos los números primos entre 1 y n.
PRACTICA 56 – Mayor Menor
Leer una serie de números hasta que el usuario ingrese el valor sentinela de -99 y escriba el número
mayor y el número menor.
PRACTICA 57 – Cuadrado
Has un programa en C++ que dibuje un cuadrado de n asteriscos.
PRACTICA 58 – Decimal a Hexadecimal
This program reads integers and prints them in hexadecimal, using the shift and "and" operators.
But there are two errors in the program. Correct the errors.
PRACTICA 59 – Rombo
Escribir un programa que lea un entero y un carácter. La salida debe ser un rombo dibujado con el
carácter dado y de anchura máxima dada por el entero leido.
PRACTICA 60 – Binario
The following program reads integers and prints them in binary by division. There are some errors.
Find them.
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 117
PRACTICA 61 – Tablas de Multiplicar
Implemente un programa que muestre por pantalla las tablas de multiplicar que el usuario quiera, y
finalice cuando el usuario indique que desea ver la tabla del cero.
PRACTICA 62 – Divisores
Implemente un programa que calcule los divisores de un número entero.
PRACTICA 63 – Calculadora
Hacer un programa que simule una calculadora. Nos mostrara el menú siguiente:
====== MENU CALCULADORA ======
1.- Sumar
2.- Restar
3.- Multiplicar
4.- Dividir
0.- Terminar
==============================
Ingrese su selección > __
El programa deberá verificar que introducimos un número válido (del 0 al 4). Si introducimos un
número erróneo nos avisará y volver a mostrar el menú. Si introducimos un 0 el programa terminar.
Si elegimos un número entre el 1 y el 4 nos pedirá dos números, mostrará el resultado
dependiendo de nuestra elección y volverá a mostrar el menú.
PRACTICA 64 – Adivinar
Diseñe un programa para jugar a adivinar un número entre 0 y 100. El programa irá dando pistas al
jugador indicándole si el número introducido por el jugador es menor o mayor que el número que
tiene que adivinar. El juego termina cuando el jugador adivina el número o decide terminar de jugar
(por ejemplo, escribiendo un número negativo).
PRACTICA 65 – Nicomaco
Considere la siguiente propiedad descubierta por Nicómaco de Gerasa. "Sumando el primer
numero impar, se obtiene el primer cubo; Sumando los dos siguientes impares se obtiene el
segundo cubo; Sumando los tres siguientes impares se obtiene el tercer cubo, etc."
Ejemplo:
1^3 = 1 = 1
2^3 = 3 + 5 = 8
3^3 = 7 + 9 + 11 = 27
4^3 = 13 + 15 + 17 + 19 = 64
5^3 = 21 + 23 + 25 + 27 + 29 = 125
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 118
Desarrolle un programa que escriba los n primeros cubos utilizando esta propiedad. El valor de n
debe ser un valor leido por teclado.
PRACTICA 66 – Perfectos
Los números perfectos son aquellos enteros que son iguales a la suma de sus divisores sin incluir a
él mismo. Ejemplo: 6 es un número perfecto porque 1 + 2 + 3 = 6. Elabore un programa que calcule
todos los números perfectos menores que un número n dado.
PRACTICA 67 – Sumatorias
Se tiene una entrada de dígitos entre 0 y 9, precedida por el número total de dígitos a leer. Dada la
entrada, se debe calcular el total de número pares, el total de números impares, el promedio de
todos los números, la sumatoria de los números pares, la sumatoria de los números impares, la
sumatoria de los cuadrados de los números pares y la sumatoria de los cuadrados de los números
impares.
PRACTICA 68 – Guess my age
Write a program to play "Guess my age:".
PRACTICA 69 – Power
Write a program to calculate the power of one number raised to another.
PRACTICA 70 – Amigos
Dos números son amigos si cada una de ellos es igual a la suma de los divisores del otro, por
ejemplo 224 y 284 son amigos ya que:
284 : 1 + 2 + 4 + 71 + 142 = 220
220 : 1 + 2 + 4 + 5 + 10 + 11 + 20 + 22 + 44 + 55 + 110 = 284
Elabore un programa que imprima todas las parejas de números amigos menores o iguales que un
numero n ingresado por teclado.
PRACTICAS CON VECTORES
PRACTICA 71 – Minimo
Hacer un programa que:
a) Lea una secuencia de 5 valores numéricos reales y los almacene en una vector.
b) Muestre por pantalla cuál es el valor mínimo, así como la posición que ocupa en el vector.
[PROGRAMACION I – C++] IDSystems 2011 - 2013
CUADERNO DE EJERCICIOS Y PRACTICAS C++ Página 119
En el caso de aparecer repetido el valor mínimo se mostrara el menor índice de los valores mínimos
PRACTICA 72 – Cafeteria
Veinte estudiantes de Ingeniería de Sistemas se les pidió que valoraran de 1 a 10 la calidad de los
almuerzos en la cafetería de la universidad. Un puntaje de 1 significa que la calidad es "pésima" y
un puntaje de 10 significa que la calidad es "excelente". Su programa deberá colocar las 20
respuestas en un arreglo de tipo int y determinar la frecuencia de cada puntaje. Las frecuencias
deben ser mostradas en forma de histograma.
PRACTICA 73 – Traductor de Codigo Morse
El objetivo de este programa consiste en realizar un traductor de número a morse.
Leyenda: — : raya (señal larga)
· : punto (señal corta)
Numeros
0 ----- 1 ·---- 2 ··--- 3 ···-- 4 ····-
5 ····· 6 -···· 7 --··· 8 ---·· 9 ----·
Cada número en morse se representará en C++ por una cadena de 5 caracteres compuesta de
puntos y rayas, según la tabla anterior. Un ejemplo de lo que debe hacer el programa es:
#morses
Entre n: 2005
..--- ----- ----- .....
#morse
Entre n: 1992
.---- ----. ----. ..---
PRACTICA 74 – Serie
Escriba un programa en C++ que calcule e imprima el promedio y la varianza de los elementos un
arreglo de 10 elementos, donde cada uno de ellos se corresponde con los elementos de la serie 1,
2^2, 3^3, 4^4, 5^5, ... .