48392863 cuadernos de ejercicios c

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



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



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



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.



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.



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:



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?



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?



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 ; }


Cual es la diferencia entre una variable normal y

las variables de preprocesador?

Como declaramos las variables de

preprocesador?



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?



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; }



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



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; }



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



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



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;}



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; }



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;



}

/* 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; }



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;



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;



return 0; }

ACCION COMANDO

¿Qué son las condiciones anidadas?

¿Cómo se escriben las condiciones anidadas?



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



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?



¿Cuáles son los comandos de archivo que

se presentan?

Realiza el pseudocódigo correspondiente:



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; }



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;



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



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.



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; }



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.



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



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



} 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:



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;



// 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:



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



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;



/* * 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) {



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



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



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");



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



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



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); }




¿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?



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.



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; }



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



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 !!!" ; }



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");



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?



¿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);



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<< " * * * *" ;



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; }



// 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?



¿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:



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



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



{ 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++;



} 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( "| . . |" );



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



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



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



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



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)



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



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



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;



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.



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.


¿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



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)



#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);



//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. =)




¿Qué es la recursión?

¿Por qué están varias

instrucciones con

comentarios?



PARTE III

ARREGLOS Y ESTRUCTURAS

A partir de aquí, usamos solamente el compilador DevC++.



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:



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; }


¿Cuál es la diferencia entre los dos programas?

¿Cómo declaramos las variables en ambos programas?



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




¿Que son los arrays multidimensionales?

¿Como generamos los numerous aleatorios?

¿Como declaramos las variables?



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];



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?



¿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



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); }


Que variables declaramos en este

programa?



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)



{ 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" ;



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]; }




¿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?



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?



¿Qué es una estructura?



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" );



} 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" ); }



(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): " );



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



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" );



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" ,&nota); 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



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



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



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



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 {



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



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): " );



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



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



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



PARTE IV

PRACTICAS PARA DESARROLLAR



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.



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



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



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.



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.



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ú



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.



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.



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.



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



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.



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

48392863 cuadernos de ejercicios c

Documents