Exámenes Resueltos FP - Primer Semestre

Para uso exclusivo con fines de estudio. Se prohíbe su uso para entregas calificables y/o uso comercial.
2019-06-20 12:26:55 +02:00 · 2019-06-20 12:26:55 +02:00 · 07651a8047
commit 07651a8047
parent 36df5ecef5
58 changed files with 4923 additions and 0 deletions
--- a/C)/ExFeb11ABC_Fernando.cpp
+++ b/C)/ExFeb11ABC_Fernando.cpp
@ -0,0 +1,289 @@
 //Examen Febrero 2011 - Grupos A, B y C.
 //Fernando Méndez Torrubiano
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 /*EJERCICIO 1*/
 const int MAX_NUM = 1000;
 const int NUM_CIFRAS = 5;
 /*EJERCICIO 2*/
 const int NUM_PIEZAS = 16 * 2;
 const int NUM_JUGADORES = 2;
 const int DIMENSIONES = 8;
 //Tipos:
 /*EJERCICIO 1*/
 typedef struct tNumero {
 	int numero;
 	int contadorCifra;
 };
 typedef tNumero tNumeros[MAX_NUM];
 typedef struct tListaNumeros {
 	tNumeros numeros;
 	int contador;
 };
 /*EJERCICIO 2*/
 typedef enum tPieza { vacia, peon, torre, caballo, alfil, reina, rey };
 typedef enum tColor { blanca, negra };
 typedef struct tCelda {
 	tPieza pieza;
 	tColor color;
 };
 typedef tCelda tTablero[DIMENSIONES][DIMENSIONES];
 typedef struct tPartida {
 	tTablero tablero;
 	int contador;
 };
 //Funciones:
 void ejecutarMenu(tListaNumeros&, tPartida&);
 int menu();
 /*EJERCICIO 1*/
 void inicializa(tListaNumeros&);
 bool cargar(tListaNumeros&);
 void procesar(tListaNumeros&);
 bool guardar(tListaNumeros&);
 /*EJERCICIO 2*/
 void iniciaTablero(tPartida&);
 bool cargar(tPartida&);
 void colocar(tPartida&, const char&, const char&, const int&, const int&);
 void posicion(tPartida&);
 void mostrarCasilla(tPartida&, const int&, const int&);
 int main() {
 	tListaNumeros listaNum;
 	tPartida partida;
 	ejecutarMenu(listaNum, partida);
 	return 0;
 }
 void ejecutarMenu(tListaNumeros& listaNum, tPartida& partida) {
 	int opc = 1;
 	while (opc != 0) {
 		opc = menu();
 		switch (opc){
 		case 0: break;
 		case 1:
 			if (cargar(listaNum)) {
 				cout << "Cargado correctamente." << endl;
 				if (guardar(listaNum)) {
 					cout << "Guardado correctamente." << endl;
 				}
 				else {
 					cout << "Vauelva a intentarlo." << endl;
 				}
 			}
 			else {
 				cout << "FIN DEL PROGRAMA." << endl;
 			}
 			system("PAUSE");
 			break;
 		case 2:
 			if (cargar(partida)) {
 				posicion(partida);
 			}
 			break;
 		default:
 			break;
 		}
 		system("cls");
 	}
 }
 int menu() {
 	int opc = 0;
 	cout << setw(35) << setfill('=') << "MENU" << setw(35) << "\n" << setfill(char(0));
 	cout << "1.-Contar numero de cifras de los numeros del archivo 'entrada.txt'." << endl;
 	cout << "2.-Partida de ajedrez." << endl;
 	cout << "0.-Salir." << endl;
 	cout << setw(70) << setfill('=') << "\n" << setfill(char(0));
 	do {
 		cout << "Introduzca una opcion: ";
 		cin >> opc;
 	} while (opc < 0 || opc > 2);
 	return opc;
 }
 /*EJERCICIO 1*/
 void inicializa(tListaNumeros& listaNum) {
 	listaNum.contador = 0;
 	for (int i = 0; i < MAX_NUM; i++) {
 		listaNum.numeros[i].numero = 0;
 		listaNum.numeros[i].contadorCifra = 1;
 	}
 }
 bool cargar(tListaNumeros& listaNum) {
 	bool carga = false;
 	ifstream archivo;
 	inicializa(listaNum);
 	archivo.open("entrada.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al cargar el archivo." << endl;
 		carga = false;
 	}
 	else{
 		while ((!archivo.eof()) && (listaNum.contador < MAX_NUM)) {
 			archivo >> listaNum.numeros[listaNum.contador].numero;
 			procesar(listaNum);
 			listaNum.contador++;
 		}
 		carga = true;
 	}
 	archivo.close();
 	return carga;
 }
 void procesar(tListaNumeros& listaNum) {
 	int aux = 0;
 	aux = listaNum.numeros[listaNum.contador].numero;
 	while (aux > 10) {
 		aux /= 10;
 		listaNum.numeros[listaNum.contador].contadorCifra++;
 	}
 }
 bool guardar(tListaNumeros& listaNum) {
 	bool guardado = false;
 	ofstream archivo;
 	archivo.open("salida.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al guardar." << endl;
 		guardado = false;
 	}
 	else {
 		archivo << setw(6) << right << "NUMERO" << setw(22) << "NUMERO DE CIFRAS" << endl;
 		archivo << setw(30) << setfill('=') << "\n" << setfill(char(0));
 		for (int i = 0; i < listaNum.contador; i++){
 			archivo << setw(5) << right << listaNum.numeros[i].numero << setw(15) << setfill('.') << listaNum.numeros[i].contadorCifra << setfill(char(0)) << endl;
 		}
 		guardado = true;
 	}
 	archivo.close();
 	return guardado;
 }
 /*EJERCICIO 2*/
 void iniciaTablero(tPartida& partida) {
 	partida.contador = 0;
 	for (int i = 0; i < DIMENSIONES; i++){
 		for (int j = 0; j < DIMENSIONES; j++){
 			partida.tablero[i][j].pieza = vacia;
 			partida.tablero[i][j].color = blanca;
 		}
 	}
 }
 bool cargar(tPartida& partida) {
 	bool carga = false;
 	ifstream archivo;
 	char tipo, color;
 	int fila, columna;
 	iniciaTablero(partida);
 	archivo.open("tablero.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al cargar." << endl;
 		carga = false;
 	}
 	else {
 		while ((!archivo.eof()) && (partida.contador < NUM_PIEZAS)) {
 			archivo >> tipo;
 			archivo >> color;
 			archivo >> fila;
 			archivo >> columna;
 			colocar(partida, tipo, color, fila, columna);
 			partida.contador++;
 		}
 		carga = true;
 	}
 	archivo.close();
 	return carga;
 }
 void colocar(tPartida& partida, const char& tipo, const char& color, const int& fila, const int& columna) {
 	if (color == 'B') {
 		partida.tablero[fila][columna].color = blanca;
 	}
 	else {
 		partida.tablero[fila][columna].color = negra;
 	}
 	switch (tipo){
 	case 'P': partida.tablero[fila][columna].pieza = peon; break;
 	case 'T': partida.tablero[fila][columna].pieza = torre; break;
 	case 'A': partida.tablero[fila][columna].pieza = alfil; break;
 	case 'C': partida.tablero[fila][columna].pieza = caballo; break;
 	case 'Q': partida.tablero[fila][columna].pieza = reina; break;
 	case 'R': partida.tablero[fila][columna].pieza = rey; break;
 	default: partida.tablero[fila][columna].pieza = vacia;
 		break;
 	}
 }
 void posicion(tPartida& partida) {
 	char continuar = 'N';
 	int fila = 0, columna = 0;
 	do {
 		do {
 			cout << "Introduzca una fila: ";
 			cin >> fila;
 		} while (fila < 0 || fila >= DIMENSIONES);
 		do {
 			cout << "Introduzca una columna: ";
 			cin >> columna;
 		} while (columna < 0 || columna >= DIMENSIONES);
 		mostrarCasilla(partida, fila, columna);
 		cout << "Quiere continuar (S/n)?";
 		cin >> continuar;
 	} while (continuar == 'S' || continuar == 's');
 }
 void mostrarCasilla(tPartida& partida, const int& fila, const int& columna) {
 	switch (partida.tablero[fila][columna].pieza){
 	case peon: cout << "Figura: PEON  "; break;
 	case torre: cout << "Figura: TORRE  "; break;
 	case alfil: cout << "Figura: ALFIL  "; break;
 	case caballo: cout << "Figura: CABALLO  "; break;
 	case reina: cout << "Figura: REINA  "; break;
 	case rey: cout << "Figura: REY  "; break;
 	default:
 		cout << "Figura: NINGUNA" << endl;
 		break;
 	}
 	switch (partida.tablero[fila][columna].color){
 	case blanca: cout << "Color: BLANCA" << endl; break;
 	case negra: cout << "Color: NEGRA" << endl; break;
 	default:
 		break;
 	}
 }
--- a/C)/Febrero2011ABC.pdf
+++ b/C)/Febrero2011ABC.pdf
--- a/Semestre)/Febrero
+++ b/Semestre)/Febrero
@ -0,0 +1,93 @@
 12345
 1
 2
 3
 4
 5
 2134
 65
 789
 44
 432
 123
 3
 561
 32
 24567
 46
 53767
 7655
 12347
 98765
 9
 788
 654
 12
 134
 5658
 542
 456
 876
 3
 56
 32333
 3233
 323
 32
 3
 12345
 1234
 123
 12
 1
 12
 123
 1234
 12345
 9
 98
 987
 9876
 98765
 9876
 987
 98
 9
 5567
 54664
 5
 75
 342
 19
 22
 23
 20
 75
 57
 10000
 1000
 100
 10
 1
 0
 96
 99
 1996
 1999
 98
 35
 9
 8
 3
 5
 7654
 743
 5
 32526
 2
 5
 5676
 23
 687
 54367
 9
--- a/Semestre)/Febrero
+++ b/Semestre)/Febrero
@ -0,0 +1,32 @@
 P B 0 4
 P B 1 6
 P B 4 3
 P B 2 7
 P B 6 5
 P B 5 4
 P B 2 0
 P B 0 2
 R B 1 1
 Q B 7 3
 A B 0 0
 A B 0 3
 C B 4 4
 C B 1 5
 T B 3 2
 T B 6 6
 P N 4 2
 P N 7 5
 P N 7 7
 P N 4 1
 P N 3 1
 P N 6 1
 P N 2 2
 P N 6 0
 R N 3 0
 Q N 5 0
 A N 0 7
 A N 4 5
 C N 5 3
 C N 3 7
 T N 3 6
 T N 4 7
--- a/G)/ExFeb12ABDG_Fernando.cpp
+++ b/G)/ExFeb12ABDG_Fernando.cpp
@ -0,0 +1,205 @@
 //Exámen Febrero 2012 - Grupos A, B, D y G.
 //Fernando Méndez Torrrubiano.
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int NUMEROS = 50;
 const int N = 5;
 //Tipos:
 typedef int tNumeros[NUMEROS];
 typedef struct tSecuencia {
 	tNumeros numero;
 	int contador;
 };
 //Funciones:
 void ejecutarMenu();
 int menu();
 void inicializa(tSecuencia&);
 void getSecuencia(tSecuencia&, const int&);
 double calcularEx(const int&, const int&);
 int factorial(const int&);
 bool guardar(tSecuencia&);
 bool esCapicua(tSecuencia&, int&);
 bool inverso(const int&);
 void guardarAnteriores(tSecuencia, const int&);
 int main() {
 	ejecutarMenu();
 	return 0;
 }
 void ejecutarMenu() {
 	tSecuencia secuencia;
 	int opc = 1, n = N, i = 0;
 	while (opc != 0){
 		opc = menu();
 		switch (opc){
 		case 0: break;
 		case 1: 
 			getSecuencia(secuencia, n); 
 			n += 2; 
 			system("PAUSE"); 
 			break;
 		case 2: 
 			if (guardar(secuencia)) {
 				if (esCapicua(secuencia, i)) {
 					cout << "El numero " << secuencia.numero[i] << " de la posicion " << i + 1<< " es capicua." << endl;
 					guardarAnteriores(secuencia, i);
 				}
 				else {
 					cout << "No se ha encontrado ningun numero capicua." << endl;
 				}
 			}
 			else {
 				cout << "No se han podido guardar los numeros anteriores." << endl;
 			}
 				system("PAUSE"); 
 				break;
 		default:
 			break;
 		}
 		system("cls");
 	}
 }
 int menu() {
 	int opc = 0;
 	cout << setw(25) << setfill('=') << "MENU" << setw(25) << "\n" << setfill(char(0));
 	cout << "1.-Calculos de 'e' elevado a 'x'" << endl;
 	cout << "2.-Detecta capicua" << endl;
 	cout << "0.-Salir" << endl;
 	cout << setw(50) << setfill('=') << "\n" << setfill(char(0));
 	do {
 		cout << "Introduzca una opcion: ";
 		cin >> opc;
 	} while (opc < 0 || opc > 2);
 	return opc;
 }
 void inicializa(tSecuencia& secuencia) {
 	secuencia.contador = 0;
 	for (int i = 0; i < NUMEROS; i++){
 		secuencia.numero[i] = 0;
 	}
 }
 void getSecuencia(tSecuencia& secuencia, const int& n) {
 	inicializa(secuencia);
 	do {
 		cout << "Introduzca un numero (-1 para terminar): ";
 		cin >> secuencia.numero[secuencia.contador];
 		if (secuencia.numero[secuencia.contador] >= 0) {
 			secuencia.contador++;
 		}
 	} while ((secuencia.numero[secuencia.contador] != -1));
 	cout << endl;
 	for (int i = 0; i < secuencia.contador; i++){
 		cout << "'e' elevado a " << secuencia.numero[i] << " da como resultado: " << fixed << setprecision(2) << calcularEx(secuencia.numero[i], n) << endl;
 	}
 }
 double calcularEx(const int& x, const int& n) {
 	double eALAx = 0;
 	for (int i = 0; i < n; i++){
 		eALAx += (pow(x, i)) / (factorial(i));
 	}
 	return eALAx;
 }
 int factorial(const int& n) {
 	int factorial = 1;
 	if (n == 0) {
 		factorial = 1;
 	}
 	else {
 		for (int i = 1; i <= n; i++) {
 			factorial *= i;
 		}
 	}
 	return factorial;
 }
 bool guardar(tSecuencia& secuencia) {
 	bool guardado = false;
 	ofstream archivo;
 	archivo.open("input.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al guardar." << endl;
 		guardado = false;
 	}
 	else {
 		for (int i = 0; i <= secuencia.contador; i++){
 			archivo << secuencia.numero[i] << endl;
 		}
 		guardado = true;
 	}
 	archivo.close();
 	return guardado;
 }
 bool esCapicua(tSecuencia& secuencia, int& i) {
 	bool encontrado = false;
 	while ((!encontrado) && (i < secuencia.contador)) {
 		if (inverso(secuencia.numero[i])) {
 			encontrado = true;
 		}
 		else {
 			i++;
 		}
 	}
 	return encontrado;
 }
 bool inverso(const int& numero) {
 	string num = to_string(numero);
 	string aux;
 	if (numero >= 10) {
 		for (int i = num.length() - 1; i >= 0; i--) {
 			aux += num[i];
 		}
 	}
 	return (num == aux) ? true : false;
 }
 void guardarAnteriores(tSecuencia secuencia, const int& i) {
 	ofstream archivo;
 	archivo.open("output.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al guardar." << endl;
 	}
 	else {
 		for (int j = 0; j < i; j++) {
 			archivo << secuencia.numero[j] << endl;
 		}
 	}
 	archivo.close();
 }
--- a/G)/Febrero2012ABDG_Fernando.pdf
+++ b/G)/Febrero2012ABDG_Fernando.pdf
--- a/G)/ExFeb13ABDG_Fernando.cpp
+++ b/G)/ExFeb13ABDG_Fernando.cpp
@ -0,0 +1,194 @@
 //Examen Febrero 2013 - Grupos A, B, D y G.
 //Fernando Méndez Torrubiano
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int MAX_NUM = 100;
 //Tipos:
 typedef int tNumeros[MAX_NUM];
 typedef struct tSecuencia {
 	tNumeros numeros;
 	int contador;
 };
 //Funciones:
 void ejecutarMenu();
 int menu();
 bool generar(tSecuencia&, const int&);
 bool guardar(tSecuencia&);
 void recorrer(tSecuencia&);
 bool esFeliz(int&);
 bool buscar(tSecuencia&, int&, int&);
 int main() {
 	ejecutarMenu();
 	return 0;
 }
 void ejecutarMenu() {
 	tSecuencia secuencia;
 	int opc = 1, maximo, error, i = 1;
 	bool generado = false;
 	while (opc != 0) {
 		opc = menu();
 		switch (opc){
 		case 0: break;
 		case 1: 
 			cout << "Introduzca el limite superior para los numeros de la secuencia: ";
 			cin >> maximo;
 			if (generar(secuencia, maximo)) {
 				cout << "Secuencia generada correctamente." << endl;
 				generado = true;
 			}
 			else {
 				cout << "Error al generar la secuencia." << endl;
 			}
 			system("PAUSE");
 			break;
 		case 2:
 			if (generado == true) {
 				recorrer(secuencia);
 			}
 			else {
 				cout << "Primero debes generar una secuencia." << endl;
 			}
 			system("PAUSE"); 
 			break;
 		case 3: 
 			if (generado == true) {
 				cout << "Introduzca un error: ";
 				cin >> error;
 				if (buscar(secuencia, error, i)) {
 					cout << "Encontrado en la linea " << i << " (diferencia: " << error << ")." << endl;
 				}
 				else {
 					cout << "No encontrado." << endl;
 				}
 			}
 			else {
 				cout << "Primero debes generar una secuencia." << endl;
 			}
 			system("PAUSE");
 			break;
 		default:
 			break;
 		}
 		system("cls");
 	}
 }
 int menu() {
 	int opc = 0;
 	cout << setw(25) << setfill('=') << "MENU" << setw(25) << "\n" << setfill(char(0));
 	cout << "1.-Generar una secuencia." << endl;
 	cout << "2.-Procesar la secuencia" << endl;
 	cout << "3.-Buscar en la secuencia." << endl;
 	cout << "0.-Salir" << endl;
 	cout << setw(50) << setfill('=') << "\n" << setfill(char(0));
 	do {
 		cout << "Introduzca una opcion: ";
 		cin >> opc;
 	} while (opc < 0 || opc > 3);
 	return opc;
 }
 bool generar(tSecuencia& secuencia, const int& maximo) {
 	secuencia.contador = 0;
 	do{
 		cout << "Introduzca un numero (0 para terminar): ";
 		cin >> secuencia.numeros[secuencia.contador];
 		if ((secuencia.numeros[secuencia.contador] < maximo) && (secuencia.numeros[secuencia.contador] > 0)) {
 			secuencia.contador++;
 		}
 	} while ((secuencia.numeros[secuencia.contador] != 0));
 	return guardar(secuencia) ? true : false;
 }
 bool guardar(tSecuencia& secuencia) {
 	bool save = false;
 	ofstream archivo;
 	archivo.open("datos.txt");
 	if (!archivo.is_open()) {
 		save = false;
 	}
 	else {
 		for (int i = 0; i < secuencia.contador; i++){
 			archivo << secuencia.numeros[i] << endl;
 		}
 		archivo << -1;
 		save = true;
 	}
 	return save;
 }
 void recorrer(tSecuencia& secuencia) {
 	int numero = 0;
 	for (int i = 0; i < secuencia.contador; i++){
 		numero = secuencia.numeros[i];
 		if (esFeliz(numero)) { cout << "El numero: " << secuencia.numeros[i] << " ES FELIZ." << endl; }
 		else { cout << "El numero: " << secuencia.numeros[i] << " NO ES FELIZ." << endl; }
 	}
 }
 bool esFeliz(int& num) {
 	int digito[10] = { 0,0,0,0,0,0,0,0,0,0 }, i = 0, aux;
 	do {
 		if (num > 10) { //Igualamos una variable auxiliar al valor anterior del número (si el número, es mayor de 10).
 			aux = num; 
 		} 
 		else { //Si el número es menor que 10, igualamos el auxiliar a 10 para que entre en el bucle y procese el número.
 			aux = 10; 
 		} 
 		while (aux >= 10) { //Si el auxiliar es mayor o igual a 10, significa que el número aun tiene más de dos cifras y por tanto hay que continuar extrayendo dichas cifras.
 			digito[i] = num % 10; //Hacemos el módulo 10 del número para extraer el digito correspondiente a las unidades.
 			num -= digito[i]; //Restamos al número el valor de las unidades, para hacerlo potencia de 10.
 			aux = num; //Igualamos una variable auxiliar al valor anterior del número. Porque en la siguiente comprobación del bucle, el número estará dividido entre 10 y daría una vuelta menos.
 			num /= 10; //Dividimos el número entre 10 para en la siguiente vuelta del bucle, seguir extrayendo el próximo dígito, que antes eran las decenas y ahora correcponderá a las unidades.
 			i++; //Sumamos uno para guardar la siguiente cifra en la próxima posición del vector. Como vamos a sumar los dígitos, nos da igual que se guarden en orden inverso.
 		}
 		num = 0;
 		for (int j = 0; j < i; j++) {
 			num += pow(digito[j], 2); //Calculamos la suma de las potencias cuadradas de cada uno de los dígitos del número.
 		}
 		i = 0;
 	} while (num >= 10);
 	return (num == 1) ? true : false;
 }
 bool buscar(tSecuencia& secuencia, int& error, int& i) {
 	bool encontrado = false;
 	while ((!encontrado) && (i < secuencia.contador)) {
 		if ((secuencia.numeros[i] - secuencia.numeros[i - 1]) < error) {
 			error = secuencia.numeros[i] - secuencia.numeros[i - 1];
 			encontrado = true;
 		}
 		i++;
 	}
 	return encontrado;
 }
--- a/G)/Febrero2013ABDG.pdf
+++ b/G)/Febrero2013ABDG.pdf
--- a/Semestre)/Febrero
+++ b/Semestre)/Febrero
@ -0,0 +1,5 @@
 7
 97
 137
 250
 -1
--- a/I)/ExFeb14ABI_Fernando.cpp
+++ b/I)/ExFeb14ABI_Fernando.cpp
@ -0,0 +1,243 @@
 //Examen Febrero 2014 - Grupos A, B e I.
 //Fernando Méndez Torrubiano.
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int NPO = 10;
 const int NPNecesitados = 1;
 //Tipos:
 typedef struct tProducto {
 	string nombre;
 	float peso;
 	float precio;
 };
 typedef tProducto tProductos[NPO];
 typedef struct tListaProductos {
 	tProductos producto;
 	int contador;
 };
 //Funciones:
 void inicializa(tListaProductos&);
 bool cargar(tListaProductos&);
 void ejecutarMenu(tListaProductos&);
 int menu();
 bool guardar(tListaProductos&);
 tListaProductos leerCesta(tListaProductos&);
 int buscarProducto(tListaProductos&, const string&);
 void realizarCompra(tListaProductos&, tListaProductos&);
 void mostrarAgotados(tListaProductos&);
 int main() {
 	tListaProductos productos;
 	if (cargar(productos)) {
 		ejecutarMenu(productos);
 		if (guardar(productos)) {
 			cout << "Guardado correctamente." << endl;
 		}
 		else {
 			cout << "Error al guardar." << endl;
 		}
 	}
 	else {
 		cout << "Fin del programa." << endl;
 	}
 	system("PAUSE");
 	return 0;
 }
 void inicializa(tListaProductos& productos) {
 	productos.contador = 0;
 	for (int i = 0; i < NPO; i++){
 		productos.producto[i].nombre = "";
 		productos.producto[i].peso = 0;
 		productos.producto[i].precio = 0;
 	}
 }
 bool cargar(tListaProductos& productos) {
 	bool carga = false;
 	ifstream archivo;
 	inicializa(productos);
 	archivo.open("almacen.txt");
 	if (!archivo.is_open()) {
 		cout << "No se ha encotrado el archivo." << endl;
 		carga = false;
 	}
 	else {
 		getline(archivo, productos.producto[productos.contador].nombre);
 		while ((productos.producto[productos.contador].nombre != "XXX") && (productos.contador < NPO)) {
 			archivo >> productos.producto[productos.contador].peso;
 			archivo >> productos.producto[productos.contador].precio;
 			productos.contador++;
 			archivo.ignore(1, ' ');
 			getline(archivo, productos.producto[productos.contador].nombre);
 		}
 		carga = true;
 	}
 	archivo.close();
 	return carga;
 }
 void ejecutarMenu(tListaProductos& productos) {
 	tListaProductos cesta;
 	int opc = 1;
 	while (opc != 0) {
 		opc = menu();
 		switch (opc){
 		case 0: break;
 		case 1: realizarCompra(productos, cesta); system("PAUSE"); break;
 		case 2: mostrarAgotados(productos); system("PAUSE"); break;
 		default:
 			break;
 		}
 		system("cls");
 	}
 }
 int menu() {
 	int opc = 0;
 	cout << setw(20) << setfill('=') << "MENU" << setw(20) << "\n" << setfill(char(0));
 	cout << "1.-Realizar la compra" << endl;
 	cout << "2.-Ver productos agotados" << endl;
 	cout << "0.-Salir" << endl;
 	cout << setw(40) << setfill('=') << "\n" << setfill(char(0));
 	do {
 		cout << "Introduzca una opcion: ";
 		cin >> opc;
 	} while (opc < 0 || opc > 2);
 	return opc;
 }
 bool guardar(tListaProductos& productos) {
 	bool guardado = false;
 	ofstream archivo;
 	archivo.open("almacen.txt");
 	if (!archivo.is_open()) {
 		guardado = false;
 	}
 	else {
 		for (int i = 0; i < productos.contador; i++){
 			archivo << productos.producto[i].nombre << endl;
 			archivo << productos.producto[i].peso << endl;
 			archivo << productos.producto[i].precio << endl;
 		}
 		archivo << "XXX";
 		guardado = true;
 	}
 	archivo.close();
 	return guardado;
 }
 tListaProductos leerCesta(tListaProductos& productos) {
 	tListaProductos cesta;
 	cesta.contador = 0;
 	string nombre;
 	int pos = 0;
 	while (cesta.contador < NPNecesitados) {
 		do {
 			cout << "Introduzca un produto: ";
 			getline(cin, nombre);
 			pos = buscarProducto(productos, nombre);
 		} while (pos == -1);
 		cesta.producto[cesta.contador].nombre = nombre;
 		do {
 			cout << "Introduzca cantidad (KG): ";
 			cin >> cesta.producto[cesta.contador].peso;
 		} while (cesta.producto[cesta.contador].peso > productos.producto[pos].peso);
 		productos.producto[pos].peso -= cesta.producto[cesta.contador].peso;
 		cesta.producto[cesta.contador].precio = cesta.producto[cesta.contador].peso * productos.producto[pos].precio;
 		cesta.contador++;
 	}
 	return cesta;
 }
 //SCARLETT JONHANSON ESTUVO AQUÍ
 //No, solo eres eva intentando gastar bromas
 //NO NO NO NO NOOOOO, bueno si. Me hacia ilu jo :,(
 //Eres idiota
 //Teniendo en cunta que tu eres yo y que yo soy tu, te estas llamando idiota a ti misma. 
 //-_-
 //:3
 //PONTE A ESTUDIAR O TE MATO!!
 // AH! 0-0 si señora.
 int buscarProducto(tListaProductos& productos, const string& nombre) {
 	int pos = productos.contador;
 	bool encontrado = false;
 	while ((!encontrado) && (pos > -1)) {
 		if (productos.producto[pos].nombre == nombre) {
 			encontrado = true;
 		}
 		else {
 			pos--;
 		}
 	}
 	return pos;
 }
 void realizarCompra(tListaProductos& productos, tListaProductos& cesta) {
 	cout << setw(15) << right << "NOMBRE"
 		<< setw(15) << "CANTIDAD"
 		<< setw(15) << "PRECIO" << endl;
 	cout << setw(25) << setfill('=') << "ALMACEN" << setw(25) << "\n" << setfill(char(0));
 	for (int i = 0; i < productos.contador; i++) {
 		cout << setw(15) << right << productos.producto[i].nombre
 			<< setw(15) << productos.producto[i].peso
 			<< setw(15) << productos.producto[i].precio << endl;
 	}
 	cout << setw(50) << setfill('=') << "\n" << setfill(char(0));
 	cesta = leerCesta(productos);
 	cout << setw(15) << right << "NOMBRE"
 		<< setw(15) << "CANTIDAD"
 		<< setw(15) << "PRECIO" << endl;
 	cout << setw(25) << setfill('=') << "CESTA" << setw(25) << "\n" << setfill(char(0));
 	for (int i = 0; i < cesta.contador; i++){
 		cout << setw(15) << right << cesta.producto[i].nombre
 			<< setw(15) << cesta.producto[i].peso
 			<< setw(15) << cesta.producto[i].precio << endl;
 	}
 	cout << setw(50) << setfill('=') << "\n" << setfill(char(0));
 }
 void mostrarAgotados(tListaProductos& productos) {
 	cout << setw(15) << right << "NOMBRE"
 		<< setw(15) << "CANTIDAD"
 		<< setw(15) << "PRECIO" << endl;
 	cout << setw(25) << setfill('=') << "AGOTADOS" << setw(25) << "\n" << setfill(char(0));
 	for (int i = 0; i < productos.contador; i++) {
 		if (productos.producto[i].peso == 0) {
 			cout << setw(15) << right << productos.producto[i].nombre
 				<< setw(15) << productos.producto[i].peso
 				<< setw(15) << productos.producto[i].precio << endl;
 		}
 	}
 	cout << setw(50) << setfill('=') << "\n" << setfill(char(0));
 }
--- a/I)/Febrero2014ABI.pdf
+++ b/I)/Febrero2014ABI.pdf
--- a/Semestre)/Febrero
+++ b/Semestre)/Febrero
@ -0,0 +1,25 @@
 Atun rojo
 80.00
 15.95
 Besugo
 80.70
 15.95
 Mejillon
 12.50
 3.00
 Caballa
 355.00
 3.00
 Lubina salvaje
 410.00
 5.85
 Gamba
 150.00
 9.95
 Merluza
 475.00
 12.50
 Salmonete
 200.40
 6.30
 XXX
--- a/F)/ExFeb14CEF_Fernando.cpp
+++ b/F)/ExFeb14CEF_Fernando.cpp
@ -0,0 +1,240 @@
 //Exámen Febrero 2014 - Grupos C, E y F.
 //Fernando Méndez Torrubinao
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int NUM_PLAYERS = 10;
 //Tipos:
 typedef struct tJugador {
 	string nombre;
 	string equipo;
 	int numPartidos;
 	int minutos;
 	int goles;
 };
 typedef tJugador tJugadores[NUM_PLAYERS];
 typedef struct tListaJugadores {
 	tJugadores jugador;
 	int contador;
 };
 //Funciones:
 void inicializa(tListaJugadores&);
 bool cargar(tListaJugadores&);
 void ejecutarMenu(tListaJugadores&);
 int menu();
 void filtrarLista(tListaJugadores&, const string&);
 bool actualizarJugador(tListaJugadores&, const string&, const int&, const int&, int& pos);
 void consultarMaxGoleador(tListaJugadores& jugadores);
 void guardar(tListaJugadores&);
 int main() {
 	tListaJugadores jugadores;
 	if (cargar(jugadores)) {
 		ejecutarMenu(jugadores);
 		guardar(jugadores);
 	}
 	else {
 		cout << "Fin del programa." << endl;
 		system("PAUSE");
 	}
 	return 0;
 }
 void inicializa(tListaJugadores& jugadores) {
 	jugadores.contador = 0;
 	for (int i = 0; i < NUM_PLAYERS; i++){
 		jugadores.jugador[i].nombre = "";
 		jugadores.jugador[i].equipo = "";
 		jugadores.jugador[i].numPartidos = 0;
 		jugadores.jugador[i].minutos = 0;
 		jugadores.jugador[i].goles = 0;
 	}
 }
 bool cargar(tListaJugadores& jugadores) {
 	bool cargado = false;
 	ifstream archivo;
 	inicializa(jugadores);
 	archivo.open("players.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al cargar el archivo." << endl;
 		cargado = false;
 	}
 	else {
 		archivo >> jugadores.jugador[jugadores.contador].nombre;
 		while ((jugadores.jugador[jugadores.contador].nombre != "XXX") && (jugadores.contador < NUM_PLAYERS)) {
 			archivo >> jugadores.jugador[jugadores.contador].equipo;
 			archivo >> jugadores.jugador[jugadores.contador].numPartidos;
 			archivo >> jugadores.jugador[jugadores.contador].minutos;
 			archivo >> jugadores.jugador[jugadores.contador].goles;
 			jugadores.contador++;
 			archivo >> jugadores.jugador[jugadores.contador].nombre;
 		}
 		cargado = true;
 	}
 	archivo.close();
 	return cargado;
 }
 void ejecutarMenu(tListaJugadores& jugadores) {
 	int opc = 1;
 	string codigo, nombre;
 	int min, goles, pos = 0;;
 	while (opc != 0) {
 		opc = menu();
 		switch (opc){
 		case 0: break;
 		case 1:
 			cout << "Introduzca equipo ('TODOS' para ver todos los jugadores): ";
 			cin >> codigo;
 			filtrarLista(jugadores, codigo); 
 			break;
 		case 2:
 			cout << "Introduzca nombre del jugador: ";
 			cin >> nombre;
 			cout << "Introduzca minutos jugados: ";
 			cin >> min;
 			cout << "Introduzca goles marcados: ";
 			cin >> goles;
 			if (actualizarJugador(jugadores, nombre, min, goles, pos)) {
 				cout << "Actualizado correctamente:" << endl;
 				cout << setw(25) << setfill('-') << "\n" << setfill(char(0))
 					<< jugadores.jugador[pos].nombre << setw(5)
 					<< jugadores.jugador[pos].equipo << setw(5)
 					<< jugadores.jugador[pos].numPartidos << setw(5)
 					<< jugadores.jugador[pos].minutos << setw(5)
 					<< jugadores.jugador[pos].goles << endl
 					<< setw(25) << setfill('-') << "\n" << setfill(char(0));
 			}
 			else {
 				cout << "Error al actualizar" << endl;
 			}
 			break;
 		case 3: consultarMaxGoleador(jugadores); break;
 		default:
 			break;
 		}
 		system("PAUSE");
 		system("cls");
 	}
 }
 int menu() {
 	int opc = 0;
 	cout << setw(40) << setfill('=') << "\n" << setfill(char(0));
 	cout << "1.-Filtrar lista." << endl;
 	cout << "2.-Actualizar jugador." << endl;
 	cout << "3.-Consultar maximo goleador" << endl;
 	cout << "0.-SALIR" << endl;
 	cout << setw(40) << setfill('=') << "\n" << setfill(char(0));
 	do {
 		cout << "Introduzca una opcion: ";
 		cin >> opc;
 	} while (opc < 0 || opc > 3);
 	return opc;
 }
 void filtrarLista(tListaJugadores& jugadores, const string& codigo) {
 	cout << setw(70) << setfill('_') << "\n" << setfill(char(0));
 	cout << endl << setw(15) << right << "JUGADOR"
 		<< setw(20) << "PARTIDOS JUGADOS"
 		<< setw(20) << "MINUTOS JUGADOS"
 		<< setw(10) << "GOLES" << endl;
 	cout << setw(70) << setfill('_') << "\n" << endl;
 	cout << setw(35) << setfill('=') << codigo << setw(35) << "\n" << setfill(char(0));
 	for (int i = 0; i < jugadores.contador; i++){
 		if ((jugadores.jugador[i].equipo == codigo) || (codigo == "TODOS") || (codigo == "todos")) {
 			cout << setw(15) << right << jugadores.jugador[i].nombre
 				<< setw(15) << jugadores.jugador[i].numPartidos
 				<< setw(20) << jugadores.jugador[i].minutos
 				<< setw(15) << jugadores.jugador[i].goles << endl;
 		}
 	}
 	cout << setw(70) << setfill('=') << "\n" << setfill(char(0));
 }
 bool actualizarJugador(tListaJugadores& jugadores, const string& nombre, const int& min, const int& goles, int& i) {
 	bool actualizado = false;
 	while ((!actualizado) && (i < jugadores.contador)) {
 		if ((jugadores.jugador[i].nombre == nombre) && (min > 0) && (goles > 0)) {
 			jugadores.jugador[i].minutos += min;
 			jugadores.jugador[i].goles += goles;
 			jugadores.jugador[i].numPartidos++;
 			actualizado = true;
 		}
 		else {
 			i++;
 		}
 	}
 	return actualizado;
 }
 void consultarMaxGoleador(tListaJugadores& jugadores) {
 	int maxGoles = 0;
 	tListaJugadores goleadores;
 	for (int i = 0; i < jugadores.contador; i++){
 		if (jugadores.jugador[i].goles > maxGoles) {
 			maxGoles = jugadores.jugador[i].goles;
 		}
 	}
 	goleadores.contador = 0;
 	cout << setw(20) << setfill('-') << "PICHICHIS" << setw(20) << setfill('-') << "\n" << setfill(char(0));
 	for (int i = 0; i < jugadores.contador; i++){
 		if (jugadores.jugador[i].goles == maxGoles) {
 			goleadores.jugador[goleadores.contador].nombre = jugadores.jugador[i].nombre;
 			goleadores.jugador[goleadores.contador].equipo = jugadores.jugador[i].equipo;
 			goleadores.jugador[goleadores.contador].numPartidos = jugadores.jugador[i].numPartidos;
 			goleadores.jugador[goleadores.contador].minutos = jugadores.jugador[i].minutos;
 			goleadores.jugador[goleadores.contador].goles = jugadores.jugador[i].goles;
 			cout << setw(10) << right << goleadores.jugador[goleadores.contador].nombre << setw(5)
 				<< goleadores.jugador[goleadores.contador].equipo << setw(5)
 				<< goleadores.jugador[goleadores.contador].numPartidos << setw(5)
 				<< goleadores.jugador[goleadores.contador].minutos << setw(5)
 				<< goleadores.jugador[goleadores.contador].goles << endl;
 			goleadores.contador++;
 		}
 	}
 	cout << setw(40) << setfill('-') << "\n" << setfill(char(0));
 }
 void guardar(tListaJugadores& jugadores) {
 	ofstream archivo;
 	archivo.open("players.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al guardar." << endl;
 		system("PAUSE");
 	}
 	else {
 		for (int i = 0; i < jugadores.contador; i++){
 			archivo << jugadores.jugador[i].nombre << " "
 				<< jugadores.jugador[i].equipo << " "
 				<< jugadores.jugador[i].numPartidos << " "
 				<< jugadores.jugador[i].minutos << " "
 				<< jugadores.jugador[i].goles << endl;
 		}
 		archivo << "XXX";
 	}
 	archivo.close();
 }
--- a/F)/Febrero2014CEF.pdf
+++ b/F)/Febrero2014CEF.pdf
--- a/Semestre)/Febrero
+++ b/Semestre)/Febrero
@ -0,0 +1,7 @@
 Messi BCN 9 810 7
 Oblack ATM 17 1545 0
 Griezmann ATM 15 1312 4
 Bale RMA 5 457 3
 Casillas RMA 0 0 0
 Costa ATM 10 755 9
 XXX
--- a/G)/ExFeb14DG_Fernando.cpp
+++ b/G)/ExFeb14DG_Fernando.cpp
@ -0,0 +1,281 @@
 //Examen Febrero 2014 - Grupos D y G.
 //Fernando Méndez Torrubiano
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int NP = 10;
 const int CLASES = 4;
 //Tipos:
 typedef enum tClase{papeleria, alimentacion, limpieza, informatica};
 typedef struct tProveedor {
 	string CIF;
 	tClase clase;
 	int pedidos;
 	int coste;
 };
 typedef tProveedor tProveedores[NP];
 typedef struct tListaProveedores {
 	tProveedores proveedor;
 	int contador;
 };
 typedef struct tGastos {
 	tClase clase;
 	int gasto;
 };
 typedef tGastos tListaGastos[CLASES];
 //Funciones:
 void inicializa(tListaProveedores&);
 bool carga(tListaProveedores&);
 void tIntToClase(tListaProveedores&, const int&);
 void ejecutarMenu(tListaProveedores&);
 int menu();
 bool guardar(tListaProveedores&);
 int buscarProveedor(tListaProveedores&, const string&);
 void nuevoPedido(tListaProveedores&, const string&, const int&);
 void mostrar(tListaProveedores&);
 void mostrarIntervalo(tListaProveedores&, const int&, const int&);
 void totalesXclase(tListaProveedores&);
 void iniciaGastos(tListaGastos&);
 int main() {
 	tListaProveedores proveedores;
 	if (carga(proveedores)) {
 		ejecutarMenu(proveedores);
 		if (guardar(proveedores)) {
 			cout << "Guardado correctamente." << endl;
 		}
 		else {
 			cout << "Error al guardar el archivo." << endl;
 		}
 	}
 	else {
 		cout << "Error al cargar el archivo." << endl;
 		system("PAUSE");
 	}
 	return 0;
 }
 void inicializa(tListaProveedores& proveedores) {
 	proveedores.contador = 0;
 	for (int i = 0; i < NP; i++){
 		proveedores.proveedor[i].CIF = "";
 		proveedores.proveedor[i].clase = informatica;
 		proveedores.proveedor[i].pedidos = 0;
 		proveedores.proveedor[i].coste = 0;
 	}
 }
 bool carga(tListaProveedores& proveedores) {
 	bool cargado = false;
 	ifstream archivo;
 	int claseAUX;
 	inicializa(proveedores);
 	archivo.open("proveedores.txt");
 	if (!archivo.is_open()) {
 		cargado = false;
 	}
 	else {
 		archivo >> proveedores.proveedor[proveedores.contador].CIF;
 		while ((proveedores.proveedor[proveedores.contador].CIF != "X") && (proveedores.contador < NP)) {
 			archivo >> claseAUX;
 			tIntToClase(proveedores, claseAUX);
 			archivo >> proveedores.proveedor[proveedores.contador].pedidos;
 			archivo >> proveedores.proveedor[proveedores.contador].coste;
 			proveedores.contador++;
 			archivo >> proveedores.proveedor[proveedores.contador].CIF;
 		}
 		cargado = true;
 	}
 	archivo.close();
 	return cargado;
 }
 void tIntToClase(tListaProveedores& proveedores, const int& aux) {
 	switch (aux){
 	case 0: proveedores.proveedor[proveedores.contador].clase = papeleria; break;
 	case 1: proveedores.proveedor[proveedores.contador].clase = alimentacion; break;
 	case 2: proveedores.proveedor[proveedores.contador].clase = limpieza; break;
 	case 3: proveedores.proveedor[proveedores.contador].clase = informatica; break;
 	default:
 		break;
 	}
 }
 void ejecutarMenu(tListaProveedores& proveedores) {
 	int opc = 1, coste, max, min;
 	string CIF;
 	while (opc != 0) {
 		opc = menu();
 		switch (opc){
 		case 0: break;
 		case 1: 
 			mostrar(proveedores);
 			cout << endl << "Introduzca el CIF para el pedido: ";
 			cin >> CIF;
 			cout << "Introduzca el coste del pedido: ";
 			cin >> coste;
 			nuevoPedido(proveedores, CIF, coste);
 			break;
 		case 2:
 			cout << "Introduzca un minimo: ";
 			cin >> min;
 			cout << "Introduzca un maximo: ";
 			cin >> max;
 			mostrarIntervalo(proveedores, max, min);
 			break;
 		case 3: totalesXclase(proveedores); break;
 		default:
 			break;
 		}
 		system("PAUSE");
 		system("cls");
 	}
 }
 int menu() {
 	int opc = 0;
 	cout << setw(25) << setfill('=') << "MENU" << setw(25) << "\n" << setfill(char(0));
 	cout << "1.-Nuevo pedido." << endl;
 	cout << "2.-Proveedores con numero de pedidos en un intervalo." << endl;
 	cout << "3.-Gastos por clase de proveedor." << endl;
 	cout << "0.-SALIR." << endl;
 	cout << setw(50) << setfill('=') << "\n" << setfill(char(0));
 	do {
 		cout << "Introduzca una opcion: ";
 		cin >> opc;
 	} while (opc < 0 || opc > 3);
 	return opc;
 }
 bool guardar(tListaProveedores& proveedores) {
 	bool guardado = false;
 	ofstream archivo;
 	archivo.open("proveedores.txt");
 	if (!archivo.is_open()) {
 		guardado = false;
 	}
 	else {
 		for (int i = 0; i < proveedores.contador; i++)
 		{
 			archivo << proveedores.proveedor[i].CIF << " "
 				<< proveedores.proveedor[i].clase << " "
 				<< proveedores.proveedor[i].pedidos << " "
 				<< proveedores.proveedor[i].coste << endl;
 		}
 		archivo << "X";
 		guardado = true;
 	}
 	archivo.close();
 	return guardado;
 }
 int buscarProveedor(tListaProveedores& proveedores, const string& CIF) {
 	int pos = proveedores.contador;
 	bool encontrado = false;
 	while ((!encontrado) && (pos > -1)) {
 		if (proveedores.proveedor[pos].CIF == CIF) {
 			encontrado = true;
 		}
 		else {
 			pos--;
 		}
 	}
 	return pos;
 }
 void nuevoPedido(tListaProveedores& proveedores, const string& CIF, const int& coste) {
 	int pos = buscarProveedor(proveedores, CIF);
 	if (pos != -1) {
 		proveedores.proveedor[pos].coste += coste;
 		proveedores.proveedor[pos].pedidos++;
 		cout << "Actualizado correctamente." << endl;
 	}
 	else {
 		cout << "CIF no encontrado." << endl;
 	}
 }
 void mostrar(tListaProveedores& proveedores) {
 	cout << endl << setw(7) << "CIF"
 		<< setw(20) << "PROVEEDOR"
 		<< setw(13) << "NUM_PEDIDOS"
 		<< setw(7) << "COSTE" << endl;
 	cout << setw(50) << setfill('=') << "\n" << setfill(char(0));
 	for (int i = 0; i < proveedores.contador; i++){
 		cout << setw(10) << right << proveedores.proveedor[i].CIF
 			<< setw(10) << proveedores.proveedor[i].clase
 			<< setw(13) << proveedores.proveedor[i].pedidos
 			<< setw(12) << proveedores.proveedor[i].coste << endl;
 	}
 	cout << setw(50) << setfill('=') << "\n" << setfill(char(0));
 }
 void mostrarIntervalo(tListaProveedores& proveedores, const int& max, const int& min) {
 	cout << endl << setw(7) << "CIF"
 		<< setw(20) << "PROVEEDOR"
 		<< setw(13) << "NUM_PEDIDOS"
 		<< setw(7) << "COSTE" << endl;
 	cout << setw(50) << setfill('=') << "\n" << setfill(char(0));
 	for (int i = 0; i < proveedores.contador; i++) {
 		if ((proveedores.proveedor[i].pedidos <= max) && (proveedores.proveedor[i].pedidos >= min)) {
 			cout << setw(10) << right << proveedores.proveedor[i].CIF
 				<< setw(10) << proveedores.proveedor[i].clase
 				<< setw(13) << proveedores.proveedor[i].pedidos
 				<< setw(12) << proveedores.proveedor[i].coste << endl;
 		}
 	}
 	cout << setw(50) << setfill('=') << "\n" << setfill(char(0));
 }
 void totalesXclase(tListaProveedores& proveedores) {
 	tListaGastos gastos;
 	iniciaGastos(gastos);
 	for (int i = 0; i < CLASES; i++){
 		for (int j = 0; j < NP; j++){
 			if (proveedores.proveedor[j].clase == gastos[i].clase) {
 				gastos[i].gasto += proveedores.proveedor[j].coste;
 			}
 		}
 		switch (gastos[i].clase){
 		case 0: cout << setw(12) << right << "Papeleria"; break;
 		case 1: cout << setw(12) << right << "Alimentacion"; break;
 		case 2: cout << setw(12) << right << "Limpieza"; break;
 		case 3: cout << setw(12) << right << "Informatica"; break;
 		default:
 			break;
 		}
 		cout << setw(10) << right << gastos[i].gasto << endl;
 	}
 }
 void iniciaGastos(tListaGastos& gastos) {
 	gastos[0].clase = papeleria;
 	gastos[1].clase = alimentacion;
 	gastos[2].clase = limpieza;
 	gastos[3].clase = informatica;
 	for (int i = 0; i < CLASES; i++){
 		gastos[i].gasto = 0;
 	}
 }
--- a/G)/Febrero2014DGDG.pdf
+++ b/G)/Febrero2014DGDG.pdf
--- a/G)/proveedores.txt
+++ b/G)/proveedores.txt
@ -0,0 +1,6 @@
 A00112233 2 4 232
 B95637245 2 1 112
 F00148231 0 22 728
 F00166230 1 3 94
 A12345678 0 123 6057
 X
--- a/G)/ExFeb15ABDIG_Fernando.cpp
+++ b/G)/ExFeb15ABDIG_Fernando.cpp
@ -0,0 +1,193 @@
 //Exámen Febrero 2015 - Grupos A, B, D, I y G.
 //Fernando Méndez Torrubiano
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int NUM_ASIG = 6;
 const int MAX_RESERVAS = 3;
 //Tipos:
 typedef struct tAsignatura {
 	string nombre;
 	float creditos;
 	int numGrupos;
 };
 typedef tAsignatura tAsignaturas[NUM_ASIG];
 typedef struct tReserva {
 	string nombre;
 	int grupos;
 };
 typedef tReserva tReservas[MAX_RESERVAS];
 typedef struct tProfesor {
 	tAsignaturas asignatura;
 	tReservas reserva;
 	int contadorA;
 	int contadorR;
 };
 //Funciones:
 void inicia(tProfesor&);
 bool cargar(tProfesor&);
 bool guardar(tProfesor&);
 void mostrarDisponibles(tProfesor&);
 void leerReservas(tProfesor&);
 int buscarAsignatura(tProfesor&, const string&);
 void realizaReserva(tProfesor&, const int&);
 int main() {
 	tProfesor profesor;
 	inicia(profesor);
 	if (cargar(profesor)) {
 		mostrarDisponibles(profesor);
 		leerReservas(profesor); 
 		mostrarDisponibles(profesor);
 		if (guardar(profesor)) {
 			cout << "Guardado correctamente." << endl;
 		}
 		else {
 			cout << "Intentelo de nuevo." << endl;
 		}
 	}
 	else {
 		cout << "Fin del programa." << endl;
 	}
 	system("PAUSE");
 	return 0;
 }
 void inicia(tProfesor& profesor) {
 	profesor.contadorA = 0;
 	profesor.contadorR = 0;
 	for (int i = 0; i < NUM_ASIG; i++){
 		profesor.asignatura[i].nombre = "";
 		profesor.asignatura[i].creditos = 0;
 		profesor.asignatura[i].numGrupos = 0;
 		if (i < MAX_RESERVAS) {
 			profesor.reserva[i].nombre = "";
 			profesor.reserva[i].grupos = 0;
 		}
 	}
 }
 bool cargar(tProfesor& profesor) {
 	bool carga = false;
 	ifstream archivo;
 	archivo.open("asignaturas.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al cargar las asignaturas." << endl;
 		carga = false;
 	}
 	else {
 		archivo >> profesor.asignatura[profesor.contadorA].nombre;
 		while ((profesor.asignatura[profesor.contadorA].nombre != "XXX") && (profesor.contadorA < NUM_ASIG)) {
 			archivo >> profesor.asignatura[profesor.contadorA].creditos;
 			archivo >> profesor.asignatura[profesor.contadorA].numGrupos;
 			profesor.contadorA++;
 			archivo >> profesor.asignatura[profesor.contadorA].nombre;
 		}
 		carga = true;
 	}
 	archivo.close();
 	return carga;
 }
 bool guardar(tProfesor& profesor) {
 	bool guardado = false;
 	ofstream archivo;
 	archivo.open("asignaturas.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al guardar las asignaturas." << endl;
 		guardado = false;
 	}
 	else {
 		for (int i = 0; i < profesor.contadorA; i++) {
 			archivo << profesor.asignatura[i].nombre << " ";
 			archivo << profesor.asignatura[i].creditos << " ";
 			archivo << profesor.asignatura[i].numGrupos << endl;
 		}
 		archivo << "XXX";
 		guardado = true;
 	}
 	archivo.close();
 	return guardado;
 }
 void mostrarDisponibles(tProfesor& profesor) {
 	cout << setw(3) << right << "NOMBRE"
 		<< setw(10) << "CREDITOS"
 		<< setw(20) << "GRUPOS DISPONIBLES" << endl;
 	cout << setw(40) << setfill('=') << "\n" << setfill(char(0));
 	for (int i = 0; i < profesor.contadorA; i++){
 		if (profesor.asignatura[i].numGrupos > 0) {
 			cout << setw(3) << right << profesor.asignatura[i].nombre
 				<< setw(10) << profesor.asignatura[i].creditos
 				<< setw(20) << profesor.asignatura[i].numGrupos << endl;
 		}
 	}
 	cout << setw(40) << setfill('=') << "\n" << setfill(char(0));
 }
 void leerReservas(tProfesor& profesor) {
 	string nombre;
 	int existe = 0, numCreditos = 0;
 	while ((nombre != "XXX") && (profesor.contadorR < MAX_RESERVAS)) {
 		cout << "Introduzca nombre de la asignatura a reservar: ";
 		cin >> nombre;
 		existe = buscarAsignatura(profesor, nombre);
 		if (existe != -1) {
 			profesor.reserva[profesor.contadorR].nombre = nombre;
 			realizaReserva(profesor, existe);
 			numCreditos += profesor.asignatura[existe].creditos;
 			profesor.contadorR++;
 		}
 		else {
 			if (nombre != "XXX") {
 				cout << "Asignatura no encontrada." << endl;
 			}
 		}
 	}
 	cout << endl << "Creditos reservados: " << numCreditos << endl << endl;
 }
 int buscarAsignatura(tProfesor& profesor, const string& nombre) {
 	int i = NUM_ASIG - 1;
 	bool encontrado = false;
 	while ((profesor.asignatura[i].nombre != nombre) && (i > -1) && (!encontrado)) {
 		if (profesor.asignatura[i].nombre == nombre) {
 			encontrado = true;
 		}
 		else {
 			i--;
 		}
 	}
 	return i;
 }
 void realizaReserva(tProfesor& profesor, const int& pos) {
 	int numGrupos = 0, resta = 0;
 	do {
 		cout << "Grupos a reservar (Quedan " << profesor.asignatura[pos].numGrupos << " grupos): ";
 		cin >> numGrupos;
 		resta = profesor.asignatura[pos].numGrupos - numGrupos;
 	} while (resta < 0);
 	profesor.asignatura[pos].numGrupos -= numGrupos;
 }
--- a/G)/Febrero2015ABIDG.pdf
+++ b/G)/Febrero2015ABIDG.pdf
--- a/G)/asignaturas.txt
+++ b/G)/asignaturas.txt
@ -0,0 +1,7 @@
 FP 6.00 8
 FC 6.00 8
 GE 3.00 2
 FEE 3.00 2
 MMI 6.50 6 
 MDL 6.00 7 
 XXX
--- a/F)/ExFeb15CEF_Fernando.cpp
+++ b/F)/ExFeb15CEF_Fernando.cpp
@ -0,0 +1,210 @@
 //Exámen Febrero 2015 - Grupos C, E y F.
 //Fernando Méndez Torrubiano
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int MAX_VIAJES = 10;
 const int NUM_PREFERENCIAS = 3;
 //Tipos:
 typedef enum tCategoria{Mochilero, Turista, Lujo};
 typedef struct tViaje {
 	string destino;
 	int duracion;
 	int plazas;
 	tCategoria categoria;
 };
 typedef tViaje tViajes[MAX_VIAJES];
 typedef struct tListaViajes {
 	tViajes viaje;
 	int contador;
 };
 typedef string tPreferencias[NUM_PREFERENCIAS];
 //Funciones:
 void inicializa(tListaViajes&);
 bool cargarCatalogo(tListaViajes&);
 void tIntToCategoria(tListaViajes&, const int&);
 void mostrarViajesEnCategoria(tListaViajes&, const int&);
 void convertirCat(const int&, tCategoria&);
 bool guardarCatalogo(tListaViajes&);
 void leerPreferencias(tPreferencias&);
 int buscarDestino(tListaViajes&, tPreferencias&, const int&);
 bool hacerReserva(tListaViajes&, const int&, tPreferencias&);
 int main() {
 	tListaViajes viajes;
 	tPreferencias preferencia;
 	int numCat;
 	if (cargarCatalogo(viajes)) {
 		cout << "Escriba una categoria (0 Mochilero, 1 Turista, 2 Lujo): ";
 		cin >> numCat;
 		mostrarViajesEnCategoria(viajes, numCat);
 		leerPreferencias(preferencia);
 		if (hacerReserva(viajes, numCat, preferencia)) {
 			cout << "Gracias por su reserva." << endl;
 			guardarCatalogo(viajes);
 		}
 		else {
 			cout << "Vuelva a intentarlo." << endl;
 		}
 	}
 	else {
 		cout << "FIN DEL PROGRAMA." << endl;
 	}
 	system("PAUSE");
 	return 0;
 }
 void inicializa(tListaViajes& viajes) {
 	viajes.contador = 0;
 	for (int i = 0; i < MAX_VIAJES; i++){
 		viajes.viaje[i].destino = "";
 		viajes.viaje[i].duracion = 0;
 		viajes.viaje[i].plazas = 0;
 		viajes.viaje[i].categoria = Mochilero;
 	}
 }
 bool cargarCatalogo(tListaViajes& viajes) {
 	bool carga = false;
 	ifstream archivo;
 	int aux = 0;
 	inicializa(viajes);
 	archivo.open("catalogoViajes.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al cargar el archivo." << endl;
 		carga = false;
 	}
 	else {
 		archivo >> viajes.viaje[viajes.contador].destino;
 		while ((viajes.viaje[viajes.contador].destino != "XXX") && (viajes.contador < MAX_VIAJES)) {
 			archivo >> viajes.viaje[viajes.contador].duracion;
 			archivo >> viajes.viaje[viajes.contador].plazas;
 			archivo >> aux;
 			tIntToCategoria(viajes, aux);
 			viajes.contador++;
 			archivo >> viajes.viaje[viajes.contador].destino;
 		}
 		carga = true;
 	}
 	archivo.close();
 	return carga;
 }
 void tIntToCategoria(tListaViajes& viajes, const int& aux) {
 	switch (aux) {
 	case 0: viajes.viaje[viajes.contador].categoria = Mochilero; break;
 	case 1: viajes.viaje[viajes.contador].categoria = Turista; break;
 	case 2: viajes.viaje[viajes.contador].categoria = Lujo; break;
 	}
 }
 void mostrarViajesEnCategoria(tListaViajes& viajes, const int& numCategoria) {
 	tCategoria categoria;
 	convertirCat(numCategoria, categoria);
 	cout << setw(10) << right << "DESTINO"
 		<< setw(15) << "DURACION"
 		<< setw(15) << "PLAZAS" << endl;
 	cout << setw(25) << setfill('=') << categoria << setw(25) << "\n" << setfill(char(0));
 	for (int i = 0; i < viajes.contador; i++){
 		if (viajes.viaje[i].categoria == categoria) {
 			cout << setw(10) << right << viajes.viaje[i].destino
 				<< setw(15) << viajes.viaje[i].duracion
 				<< setw(15) << viajes.viaje[i].plazas << endl;
 		}
 	}
 	cout << setw(50) << setfill('=') << "\n" << setfill(char(0));
 }
 void convertirCat(const int& numCategoria, tCategoria& categoria) {
 	switch (numCategoria) {
 	case 0: categoria = Mochilero; break;
 	case 1: categoria = Turista; break;
 	case 2: categoria = Lujo; break;
 	}
 }
 bool guardarCatalogo(tListaViajes& viajes) {
 	bool guardado = false;
 	ofstream archivo;
 	archivo.open("catalogoViajes.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al guardar el archivo." << endl;
 		guardado = false;
 	}
 	else {
 		for (int i = 0; i < viajes.contador; i++){
 			archivo << viajes.viaje[i].destino << " "
 				<< viajes.viaje[i].duracion << " "
 				<< viajes.viaje[i].plazas << " "
 				<< viajes.viaje[i].categoria << endl;
 		}
 		archivo << "XXX";
 		guardado = true;
 	}
 	archivo.close();
 	return guardado;
 }
 void leerPreferencias(tPreferencias& preferencia) {
 	for (int i = 0; i < NUM_PREFERENCIAS; i++) {
 		cout << "Escriba sus destinos preferentes (de mayor a menor): ";
 		cin >> preferencia[i];
 	}
 }
 int buscarDestino(tListaViajes& viajes, tPreferencias& preferencias, const int& numCategoria) {
 	int i = 0, pos = viajes.contador - 1;
 	tCategoria categoria;
 	bool encontrado = false;
 	convertirCat(numCategoria, categoria);
 	while ((i < NUM_PREFERENCIAS) && (!encontrado)) {
 		pos = viajes.contador - 1;
 		while ((pos > -1) && (!encontrado)) {
 			if ((viajes.viaje[pos].destino == preferencias[i]) && (viajes.viaje[pos].categoria == categoria) && (viajes.viaje[pos].plazas > 0)) {
 				encontrado = true;
 			}
 			else {
 				pos--;
 			}
 		}
 		i++;
 	}
 	return pos;
 }
 bool hacerReserva(tListaViajes& viajes, const int& numCategoria, tPreferencias& preferencias) {
 	bool reserva = false;
 	int posReserva = buscarDestino(viajes, preferencias, numCategoria);
 	if (posReserva != -1) {
 		cout << "Reservado viaje a " << viajes.viaje[posReserva].destino << endl;
 		viajes.viaje[posReserva].plazas--;
 		reserva = true;
 	}
 	else {
 		cout << "No hay disponibilidad para esas preferencias." << endl;
 		reserva = false;
 	}
 	return reserva;
 }
--- a/F)/Febrero2015CEF.pdf
+++ b/F)/Febrero2015CEF.pdf
--- a/F)/catalogoViajes.txt
+++ b/F)/catalogoViajes.txt
@ -0,0 +1,7 @@
 Nepal 10 2 0
 Mongolia 15 0 0
 Viena 3 8 2
 Viena 3 2 1
 Sicilia 5 1 1
 Las-Vegas 4 2 0
 XXX
--- a/H)/ExFeb15DGH_Fernando.cpp
+++ b/H)/ExFeb15DGH_Fernando.cpp
@ -0,0 +1,255 @@
 //Examen Febrero 2015 - Grupos D, G y H
 //Fernando Méndez Torrubiano
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int NUM_PROD = 5;
 const int NUM_PED = 3;
 //Tipos:
 typedef struct tProducto {
 	string codigo;
 	string descripcion;
 	float precio;
 	bool oferta;
 };
 typedef tProducto tProductos[NUM_PROD];
 typedef struct tListaProductos {
 	tProductos producto;
 	int contador;
 };
 typedef struct tCesta {
 	string nombre;
 	int unidades;
 	float precioProducto;
 };
 typedef tCesta tCestas[NUM_PED];
 typedef struct tPedidos{
 	tCestas cesta;
 	int contador;
 };
 //Funciones:
 void inicia(tListaProductos&, tPedidos&);
 bool cargar(tListaProductos&);
 void ejecutarMenu(tListaProductos&, tPedidos&);
 int menu();
 void muestraProductos(tListaProductos&);
 string tBoolToString(tListaProductos&, const int&);
 void crearCesta(tListaProductos&, tPedidos&);
 bool buscarProducto(const tListaProductos&, const tPedidos&);
 bool procesaCesta(tListaProductos&, tPedidos&);
 float total(tListaProductos&, tPedidos&, const int&, float&);
 int main() {
 	tListaProductos productos;
 	tPedidos pedidos;
 	inicia(productos, pedidos);
 	if (cargar(productos)) {
 		ejecutarMenu(productos, pedidos);
 	}
 	return 0;
 }
 void inicia(tListaProductos& productos, tPedidos& pedidos) {
 	productos.contador = 0;
 	pedidos.contador = 0;
 	for (int i = 0; i < NUM_PROD; i++){
 		productos.producto[i].codigo = "";
 		productos.producto[i].descripcion = "";
 		productos.producto[i].precio = 0;
 		productos.producto[i].oferta = false;
 		if (i < NUM_PED) {
 			pedidos.cesta[i].nombre = "";
 			pedidos.cesta[i].unidades = 0;
 			pedidos.cesta[i].precioProducto = 0;
 		}
 	}
 }
 bool cargar(tListaProductos& productos) {
 	bool carga = false;
 	ifstream archivo;
 	archivo.open("productos.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al cargar la lista de productos." << endl;
 		carga = false;
 	}
 	else {
 		archivo >> productos.producto[productos.contador].codigo;
 		while ((productos.producto[productos.contador].codigo != "XXX") && (productos.contador < NUM_PROD)) {
 			archivo >> productos.producto[productos.contador].precio;
 			archivo >> productos.producto[productos.contador].oferta;
 			getline(archivo, productos.producto[productos.contador].descripcion);
 			productos.contador++;
 			archivo >> productos.producto[productos.contador].codigo;
 		}
 		carga = true;
 	}
 	archivo.close();
 	return carga;
 }
 void ejecutarMenu(tListaProductos& productos, tPedidos& pedidos) {
 	int opc = 1;
 	while (opc != 0) {
 		muestraProductos(productos);
 		opc = menu();
 		switch (opc){
 		case 0: break;
 		case 1: crearCesta(productos, pedidos); break;
 		case 2: procesaCesta(productos, pedidos); break;
 		default:
 			break;
 		}
 		system("cls");
 	}
 }
 int menu() {
 	int opc = 0;
 	cout << endl << setw(40) << setfill('=') << "\n" << setw(char(0));
 	cout << "1.-Añadir productos a la cesta." << endl;
 	cout << "2.-Confirmar pedido." << endl;
 	cout << "0.-SALIR." << endl;
 	cout << setw(40) << setfill('=') << "\n" << setw(char(0));
 	do {
 		cout << "Introduzca una opcion: ";
 		cin >> opc;
 	} while (opc < 0 || opc > 2);
 	return opc;
 }
 void muestraProductos(tListaProductos& productos) {
 	cout << setw(5) << right << "CODIGO"
 		<< setw(25) << "DESCRIPCION"
 		<< setw(15) << "PRECIO"
 		<< setw(15) << "OFERTA" << endl;
 	cout << setw(70) << setfill('=') << "\n" << setfill(char(0));
 	for (int i = 0; i < productos.contador; i++){
 		cout << setw(5) << right << productos.producto[i].codigo
 			<< setw(25) << productos.producto[i].descripcion
 			<< setw(15) << productos.producto[i].precio
 			<< setw(15) << tBoolToString(productos, i) << endl;
 	}
 	cout << setw(70) << setfill('=') << "\n" << setfill(char(0));
 }
 string tBoolToString(tListaProductos& productos, const int& pos) {
 	string oferta;
 	switch (productos.producto[pos].oferta){
 	case false: oferta = "NO"; break;
 	case true: oferta = "SI"; break;
 	}
 	return oferta;
 }
 void crearCesta(tListaProductos& productos, tPedidos& pedidos) {
 	int i = 0;
 	while ((pedidos.contador < NUM_PED) && (pedidos.cesta[pedidos.contador].nombre != "XXX")) {
 		cout << "Introduzca un codigo de producto: ";
 		cin >> pedidos.cesta[pedidos.contador].nombre;
 		while (!buscarProducto(productos, pedidos)) {
 			cout << "Producto no encontrado. Introduzca otro codigo: ";
 			cin >> pedidos.cesta[pedidos.contador].nombre;
 		}
 		if (pedidos.cesta[pedidos.contador].nombre != "XXX") {
 			cout << "Introduzca un cantidad de productos: ";
 			cin >> pedidos.cesta[pedidos.contador].unidades;
 			pedidos.contador++;
 		}
 	}
 	cout << "Cesta llena." << endl;
 	system("PAUSE");
 }
 bool buscarProducto(const tListaProductos& productos, const tPedidos& pedidos) {
 	bool encontrado = false;
 	int i = 0;
 	while ((!encontrado) && (i < productos.contador)) {
 		if ((pedidos.cesta[pedidos.contador].nombre == productos.producto[i].codigo) || (pedidos.cesta[pedidos.contador].nombre == "XXX")) {
 			encontrado = true;
 		}
 		else {
 			i++;
 		}
 	}
 	return encontrado;
 }
 bool procesaCesta(tListaProductos& productos, tPedidos& pedidos) {
 	bool procesado = false;
 	ofstream archivo;
 	float totalPrecio = 0;
 	archivo.open("ticket.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al procesar el pedido." << endl;
 		procesado = false;
 	}
 	else {
 		for (int i = 0; i < pedidos.contador; i++){
 			archivo << pedidos.cesta[i].nombre << " x "
 				<< pedidos.cesta[i].unidades << " = ";
 			totalPrecio = total(productos, pedidos, i, totalPrecio);
 			archivo << pedidos.cesta[i].precioProducto << endl;
 		}
 		archivo << "Total compra: " << totalPrecio << endl;
 		procesado = true;
 	}
 	archivo.close();
 	if(procesado == true){
 		cout << "Precio total: " << totalPrecio << endl;
 	}
 	else{
 		cout << "Intentelo de nuevo." << endl;
 	}
 	system("PAUSE");
 	return procesado;
 }
 float total(tListaProductos& productos, tPedidos& pedidos, const int& pos, float& total) {
 	int j = 0;
 	bool encontrado = false;
 	float descuento = 0;
 	while ((!encontrado) && (j < productos.contador)) {
 		if (pedidos.cesta[pos].nombre == productos.producto[j].codigo) {
 			if (productos.producto[j].oferta) {
 				descuento = (productos.producto[j].precio * 0.15);
 				total += (productos.producto[j].precio - descuento);
 				pedidos.cesta[pos].precioProducto = (productos.producto[j].precio - descuento);
 			}
 			else {
 				total += productos.producto[j].precio;
 				pedidos.cesta[pos].precioProducto = productos.producto[j].precio;
 			}
 			encontrado = true;
 		}
 		else {
 			j++;
 		}
 	}
 	return total;
 }
--- a/H)/Febrero2015DGH.pdf
+++ b/H)/Febrero2015DGH.pdf
--- a/Semestre)/Febrero
+++ b/Semestre)/Febrero
@ -0,0 +1,5 @@
 L0001 1.25 0 Leche
 PC010 3.15 0 Pasta de dientes
 H0025 1.50 0 Huevos
 Y8912 1.50 1 Pack de 6 yogures
 XXX
--- a/G)/ExFeb16FG_Fernando.cpp
+++ b/G)/ExFeb16FG_Fernando.cpp
@ -0,0 +1,279 @@
 //Exámen Febro de 2016.
 //Grupos F y G.
 //Fernando Méndez Torubiano
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int NUM_EQUIPOS = 25;
 //Tipos:
 typedef enum tCategoria{principiante, intermedio, avanzado, experto};
 typedef struct tEquipo {
 	string nombre;
 	tCategoria liga;
 	int partidasJugadas;
 	int partidasGanadas;
 	bool disponible;
 };
 typedef tEquipo tEquipos[NUM_EQUIPOS];
 typedef struct tListaEquipos {
 	tEquipos equipo;
 	int contador;
 };
 //Funciones:
 void inicializa(tListaEquipos&);
 bool cargarDatos(tListaEquipos&);
 void guardarDatos(tListaEquipos&);
 void tInttoLiga(tListaEquipos&, const int);
 int menu();
 void ejecutarMenu(tListaEquipos&);
 void jugarPartida(tListaEquipos&);
 bool buscarEquipos(tListaEquipos&, const string, int&);
 bool buscarContrarios(tListaEquipos&, const int, string&);
 void apuntarResultado(tListaEquipos&);
 void actualizarGanador(tListaEquipos&, const int&);
 void actualizarPerdedor(tListaEquipos&, const int&);
 int main() {
 	tListaEquipos equipos;
 	if (cargarDatos(equipos)) {
 		ejecutarMenu(equipos);
 	}
 	else {
 		cout << "Fin del programa." << endl;
 		system("PAUSE");
 	}
 	return 0;
 }
 void inicializa(tListaEquipos& equipos) {
 	equipos.contador = 0;
 	for (int i = 0; i < NUM_EQUIPOS; i++){
 		equipos.equipo[i].nombre = "";
 		equipos.equipo[i].liga = principiante;
 		equipos.equipo[i].partidasJugadas = 0;
 		equipos.equipo[i].partidasGanadas = 0;
 		equipos.equipo[i].disponible = false;
 	}
 }
 bool cargarDatos(tListaEquipos& equipos) {
 	bool carga = false;
 	ifstream archivo;
 	int AUXliga = 0;
 	inicializa(equipos);
 	archivo.open("equipos.txt");
 	if (!archivo.is_open()) {
 		cout << "Archivo no encontrado." << endl;
 		carga = false;
 	}
 	else {
 		archivo >> equipos.equipo[equipos.contador].nombre;
 		while ((equipos.equipo[equipos.contador].nombre != "XXX") && (equipos.contador < NUM_EQUIPOS)) {
 			archivo >> AUXliga;
 			tInttoLiga(equipos, AUXliga);
 			archivo >> equipos.equipo[equipos.contador].partidasJugadas;
 			archivo >> equipos.equipo[equipos.contador].partidasGanadas;
 			archivo >> equipos.equipo[equipos.contador].disponible;
 			equipos.contador++;
 			archivo >> equipos.equipo[equipos.contador].nombre;
 		}
 		carga = true;
 	}
 	archivo.close();
 	return carga;
 }
 void tInttoLiga(tListaEquipos& equipos, const int AUXliga) {
 	switch (AUXliga){
 	case 0: equipos.equipo[equipos.contador].liga = principiante; break;
 	case 1: equipos.equipo[equipos.contador].liga = intermedio; break;
 	case 2: equipos.equipo[equipos.contador].liga = avanzado; break;
 	case 3: equipos.equipo[equipos.contador].liga = experto; break;
 	}
 }
 int menu() {
 	int opc = 0;
 	cout << setw(25) << setfill('=') << "\n";
 	cout << "1.- Jugar Partida." << endl;
 	cout << "2.- Apuntar resultado." << endl;
 	cout << "0.- Salir." << endl;
 	cout << setw(25) << setfill('=') << "\n" << setw(0) << setfill(char(0));
 	do {
 		cout << "Introduzca una opcion: ";
 		cin >> opc;
 	} while (opc < 0 || opc > 2);
 	return opc;
 }
 void ejecutarMenu(tListaEquipos& equipos) {
 	int opc = 1;
 	while (opc != 0) {
 		opc = menu();
 		switch (opc){
 		case 1: jugarPartida(equipos); break;
 		case 2: apuntarResultado(equipos); break;
 		case 0: guardarDatos(equipos); break;
 		default:
 			break;
 		}
 		system("cls");
 	}
 }
 void jugarPartida(tListaEquipos& equipos) {
 	string nomEquipo, nomContrario;
 	int pos = 0;
 	cout << "Introduzca el nombre de su equipo: ";
 	cin >> nomEquipo;
 	if (buscarEquipos(equipos, nomEquipo, pos)) {
 		if (buscarContrarios(equipos, pos, nomContrario)) {
 			cout << "Rival encontrado: " << nomContrario << endl;
 		}
 		else {
 			equipos.equipo[pos].disponible = true;
 		}
 	}
 	else {
 		cout << "Equipo no encontrado." << endl;
 	}
 	system("PAUSE");
 }
 bool buscarEquipos(tListaEquipos& equipos, const string nomEquipo, int& posicion) {
 	bool encontrado = false;
 	while ((!encontrado) && (posicion < equipos.contador)) {
 		if (equipos.equipo[posicion].nombre == nomEquipo) {
 			encontrado = true;
 		}
 		else {
 			posicion++;
 		}
 	}
 	return encontrado;
 }
 bool buscarContrarios(tListaEquipos& equipos, const int pos, string& nomContrario) {
 	bool encontrado = false;
 	int i = 0;
 	int numPartidasJugadas = 25;
 	for (int i = 0; i < equipos.contador; i++) {
 		if ((equipos.equipo[i].liga == equipos.equipo[pos].liga) && (i != pos) && (numPartidasJugadas >= equipos.equipo[i].partidasJugadas)) {
 			numPartidasJugadas = equipos.equipo[i].partidasJugadas;
 		}
 	}
 	while ((!encontrado) && (i < equipos.contador)) {
 		if ((equipos.equipo[i].liga == equipos.equipo[pos].liga) && (i != pos) && (numPartidasJugadas == equipos.equipo[i].partidasJugadas)) {
 			nomContrario = equipos.equipo[i].nombre;
 			encontrado = true;
 		}
 		else {
 			i++;
 		}
 	}
 	return encontrado;
 }
 void apuntarResultado(tListaEquipos& equipos) {
 	string nomGanador, nomPerdedor;
 	int posGanador = 0, posPerdedor = 0;
 	do {
 		cout << "Introduzca el nombre del equipo GANADOR: ";
 		cin >> nomGanador;
 	} while (!buscarEquipos(equipos, nomGanador, posGanador));
 	actualizarGanador(equipos, posGanador);
 	do {
 		cout << "Introduzca el nombre del equipo PERDEDOR: ";
 		cin >> nomPerdedor;
 	} while (!buscarEquipos(equipos, nomPerdedor, posPerdedor));
 	actualizarPerdedor(equipos, posPerdedor);
 	cout << endl << "Resultados actualizados correctamente." << endl;
 	system("PAUSE");
 }
 void actualizarGanador(tListaEquipos& equipos, const int& pos) {
 	int partidasPerdidas = 0, diferencia = 0;
 	equipos.equipo[pos].partidasJugadas++;
 	equipos.equipo[pos].partidasGanadas++;
 	partidasPerdidas = equipos.equipo[pos].partidasJugadas - equipos.equipo[pos].partidasGanadas;
 	diferencia = equipos.equipo[pos].partidasGanadas - partidasPerdidas;
 	if (diferencia > 25) {
 		switch (equipos.equipo[pos].liga) {
 		case principiante: equipos.equipo[pos].liga = intermedio; break;
 		case intermedio: equipos.equipo[pos].liga = avanzado; break;
 		case avanzado: equipos.equipo[pos].liga = experto; break;
 		case experto: equipos.equipo[pos].liga = experto; break;
 		}
 		equipos.equipo[pos].partidasJugadas = 0;
 		equipos.equipo[pos].partidasGanadas = 0;
 	}
 	equipos.equipo[pos].disponible = false;
 }
 void actualizarPerdedor(tListaEquipos& equipos, const int& pos) {
 	int partidasPerdidas = 0;
 	equipos.equipo[pos].partidasJugadas++;
 	partidasPerdidas = equipos.equipo[pos].partidasJugadas - equipos.equipo[pos].partidasGanadas;
 	if (partidasPerdidas > 20) {
 		switch (equipos.equipo[pos].liga) {
 		case principiante: equipos.equipo[pos].liga = principiante; break;
 		case intermedio: equipos.equipo[pos].liga = principiante; break;
 		case avanzado: equipos.equipo[pos].liga = intermedio; break;
 		case experto: equipos.equipo[pos].liga = avanzado; break;
 		}
 		equipos.equipo[pos].partidasJugadas = 0;
 		equipos.equipo[pos].partidasGanadas = 0;
 	}
 	equipos.equipo[pos].disponible = false;
 }
 void guardarDatos(tListaEquipos& equipos) {
 	ofstream archivo;
 	archivo.open("equipos.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al guardar el archivo." << endl;
 		system("PAUSE");
 	}
 	else {
 		for (int i = 0; i < equipos.contador; i++){
 			archivo << equipos.equipo[i].nombre << endl;
 			archivo << equipos.equipo[i].liga << " ";
 			archivo << equipos.equipo[i].partidasJugadas << " ";
 			archivo << equipos.equipo[i].partidasGanadas << " ";
 			archivo << equipos.equipo[i].disponible << endl;
 		}
 		archivo << "XXX";
 	}
 	archivo.close();
 }
--- a/G)/Febrero2016-FG.pdf
+++ b/G)/Febrero2016-FG.pdf
--- a/Semestre)/Febrero
+++ b/Semestre)/Febrero
@ -0,0 +1,21 @@
 EquipoA
 3 9 8 0
 EquipoB
 3 4 1 0
 EquipoC
 0 5 4 0
 EquipoD
 2 3 2 1
 EquipoE
 1 2 1 0
 EquipoF
 2 5 3 1
 EquipoG
 2 6 1 1
 EquipoH
 2 5 2 1
 EquipoI
 1 4 1 0
 EquipoJ
 0 3 0 1
 XXX
--- a/I)/ExFeb16ABCI_Fernando.cpp
+++ b/I)/ExFeb16ABCI_Fernando.cpp
@ -0,0 +1,224 @@
 //Exámen Febrero 2016 - Grupos A, B, C e I
 //Fernando Méndez Torrubiano
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int N = 50;
 //Tipos:
 typedef enum { embarcando, operado, retrasado, suspendido }tEstado;
 typedef struct {
 	string numVuelo;
 	char terminal;
 	int puertaEmb;
 	tEstado estVuelo;
 	string destino;
 }tVuelo;
 typedef tVuelo tVuelos[N];
 typedef struct {
 	tVuelos vuelo;
 	int contador;
 }tListaVuelos;
 //Funciones:
 void inizializa(tListaVuelos&);
 bool cargar(tListaVuelos&);
 void tIntToEstado(tListaVuelos&, const int);
 int menu();
 void ejecutarMenu(tListaVuelos&);
 void guardar(tListaVuelos&);
 void obtenerInfoVuelo(tListaVuelos&);
 void actualizaEstVuelo(tListaVuelos&);
 int buscarVuelo(tListaVuelos&, const string&);
 void mostrarVuelo(tListaVuelos&, const string&);
 void actualizarVuelo(tListaVuelos&, const int&, const int&);
 int main() {
 	tListaVuelos vuelos;
 	if (cargar(vuelos)) {
 		ejecutarMenu(vuelos);
 	}
 	else {
 		cout << "Fin del programa." << endl;
 		system("PAUSE");
 	}
 	return 0;
 }
 void inicializa(tListaVuelos& vuelos) {
 	vuelos.contador = 0;
 	for (int i = 0; i < N; i++) {
 		vuelos.vuelo[i].numVuelo = "";
 		vuelos.vuelo[i].terminal = char(0);
 		vuelos.vuelo[i].puertaEmb = 0;
 		vuelos.vuelo[i].estVuelo = suspendido;
 		vuelos.vuelo[i].destino = "";
 	}
 }
 bool cargar(tListaVuelos& vuelos) {
 	bool carga = false;
 	int AUX;
 	ifstream archivo;
 	inicializa(vuelos);
 	archivo.open("salidas.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al cargar el archivo." << endl;
 		carga = false;
 	}
 	else {
 		archivo >> vuelos.vuelo[vuelos.contador].numVuelo;
 		while ((vuelos.vuelo[vuelos.contador].numVuelo != "XXX") && (vuelos.contador < N)) {
 			archivo >> vuelos.vuelo[vuelos.contador].terminal;
 			archivo >> vuelos.vuelo[vuelos.contador].puertaEmb;
 			archivo >> AUX;
 			tIntToEstado(vuelos, AUX);
 			getline(archivo, vuelos.vuelo[vuelos.contador].destino);
 			vuelos.contador++;
 			archivo >> vuelos.vuelo[vuelos.contador].numVuelo;
 		}
 		carga = true;
 	}
 	archivo.close();
 	return carga;
 }
 void tIntToEstado(tListaVuelos& vuelos, const int AUX) {
 	switch (AUX) {
 		case 0: vuelos.vuelo[vuelos.contador].estVuelo = embarcando; break;
 		case 1: vuelos.vuelo[vuelos.contador].estVuelo = operado; break;
 		case 2: vuelos.vuelo[vuelos.contador].estVuelo = retrasado; break;
 		case 3: vuelos.vuelo[vuelos.contador].estVuelo = suspendido; break;
 	}
 }
 int menu() {
 	int opc = 0;
 	cout << setw(40) << setfill('=') << "\n";
 	cout << "1.-Obtener informacion de un vuelo." << endl;
 	cout << "2.-Actualizar estado del un vuelo." << endl;
 	cout << "0.-Salir." << endl;
 	cout << setw(40) << setfill('=') << "\n" << setw(0) << setfill(char(0));
 	do {
 		cout << "Introduzca una opcion: ";
 		cin >> opc;
 	} while (opc < 0 || opc > 2);
 	return opc;
 }
 void ejecutarMenu(tListaVuelos& vuelos) {
 	int opc = 1;
 	while (opc != 0) {
 		opc = menu();
 		switch (opc) {
 		case 1: obtenerInfoVuelo(vuelos); break;
 		case 2: actualizaEstVuelo(vuelos); break;
 		case 0: guardar(vuelos); break;
 		}
 		system("cls");
 	}
 }
 void guardar(tListaVuelos& vuelos) {
 	ofstream archivo;
 	archivo.open("pendientes.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al guardar." << endl;
 	}
 	else {
 		for (int i = 0; i < vuelos.contador; i++){
 			if ((vuelos.vuelo[i].estVuelo == retrasado) || (vuelos.vuelo[i].estVuelo == suspendido)) {
 				archivo << vuelos.vuelo[i].numVuelo << " ";
 				archivo << vuelos.vuelo[i].terminal << " ";
 				archivo << vuelos.vuelo[i].puertaEmb << " ";
 				archivo << vuelos.vuelo[i].estVuelo << "";
 				archivo << vuelos.vuelo[i].destino << endl;
 			}
 		}
 	}
 	archivo.close();
 }
 void obtenerInfoVuelo(tListaVuelos& vuelos) {
 	string numVuelo;
 	int encontrado;
 	cout << "Introduzca numero de vuelo: ";
 	cin >> numVuelo;
 	encontrado = buscarVuelo(vuelos, numVuelo);
 	if (encontrado != -1) {
 		mostrarVuelo(vuelos, numVuelo);
 	}
 	else {
 		cout << "Vuelo no encontrado." << endl;
 	}
 	system("PAUSE");
 }
 void actualizaEstVuelo(tListaVuelos& vuelos) {
 	string numVuelo;
 	int encontrado;
 	int nuevoEst;
 	do {
 		cout << "Introduzca un numero de vuelo: ";
 		cin >> numVuelo;
 		encontrado = buscarVuelo(vuelos, numVuelo);
 	} while (encontrado == -1);
 	cout << endl << "ESTADOS: (0)embarcando, (1)operado, (2)retrasado, (3)suspendido." << endl;
 	cout << "Introduzca un nuevo estado: ";
 	cin >> nuevoEst;
 	actualizarVuelo(vuelos, encontrado, nuevoEst);
 	cout << "Actualizado correctamente." << endl;
 	system("PAUSE");
 }
 int buscarVuelo(tListaVuelos& vuelos, const string& numVuelo) {
 	int pos = 0;
 	while ((vuelos.vuelo[pos].numVuelo != numVuelo) && (pos < vuelos.contador)) {
 		pos++;
 	}
 	if (pos == vuelos.contador) {
 		pos = -1;
 	}
 	return pos;
 }
 void mostrarVuelo(tListaVuelos& vuelos, const string& numVuelo) {
 	int pos = buscarVuelo(vuelos, numVuelo);
 	cout << setw(50) << setfill('=') << "\n" << setfill(char(0));
 	cout << "Numero de vuelo: " << setw(15) << vuelos.vuelo[pos].numVuelo << endl
 		<< "Terminal: " << setw(15) << vuelos.vuelo[pos].terminal << endl
 		<< "Puerta de Embarque: " << setw(15) << vuelos.vuelo[pos].puertaEmb << endl
 		<< "Estado: " << setw(15) << vuelos.vuelo[pos].estVuelo << endl
 		<< "Destino: " << setw(15) << vuelos.vuelo[pos].numVuelo << endl;
 	cout << setw(50) << setfill('=') << "\n" << setfill(char(0));
 }
 void actualizarVuelo(tListaVuelos& vuelos, const int& pos, const int& estadVuelo) {
 	switch (estadVuelo) {
 	case 0: vuelos.vuelo[pos].estVuelo = embarcando; break;
 	case 1: vuelos.vuelo[pos].estVuelo = operado; break;
 	case 2: vuelos.vuelo[pos].estVuelo = retrasado; break;
 	case 3: vuelos.vuelo[pos].estVuelo = suspendido; break;
 	}
 }
--- a/I)/Febrero2016_ABCI.pdf
+++ b/I)/Febrero2016_ABCI.pdf
--- a/Semestre)/Febrero
+++ b/Semestre)/Febrero
@ -0,0 +1,9 @@
 IB1231 A 2 1 Lisboa
 AF1231 A 3 1 Paris
 KLM1231 B 1 2 Amsterdam
 AL1236 A 3 1 Roma
 LU1301 A 5 0 Zagreb
 TP1302 B 2 2 Oporto
 AM1401 B 1 0 Cancun
 AV1411 B 3 3 Sao Paulo
 XXX
--- a/G)/ExFeb17AEDG_Eva.cpp
+++ b/G)/ExFeb17AEDG_Eva.cpp
@ -0,0 +1,151 @@
 // Eva Verdú Rodríguez 51220965B
 // LAB: 10
 // PTO: 12
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 const int MAX_APUNTES = 500;
 typedef struct tFecha {
 	int dia;
 	int mes;
 	int año;
 };
 typedef struct tApunte {
 	tFecha fecha;
 	float impor;
 	string concep;
 };
 typedef struct tCuenta {
 	tApunte apunte [MAX_APUNTES];
 	int cont;
 };
 int menu();
 void cargar(tCuenta & cuenta, string fichero);
 void Nomina(const tCuenta cuenta);
 void GastoLuzAño(const tCuenta cuenta, int año);
 void mostrar(const tCuenta cuenta);
 int main() {
 	int opc, año;
 	tCuenta cuenta;
 	cuenta.cont = 0;
 	string fichero = "apuntes.txt";
 	opc = menu();
 	do{
 		switch (opc) {
 		case 1:
 			cargar(cuenta, fichero);
 			break;
 		case 2:
 			Nomina(cuenta);
 			break;
 		case 3:
 			cout << "Introduzca año para calcular el gasto medio: ";
 			cin >> año;
 			GastoLuzAño(cuenta, año);
 			break;
 		case 4:
 			mostrar(cuenta);
 			break;
 		}
 		opc = menu();
 	} while (opc != 0);
 	system("pause");
 	return 0;
 }
 int menu() {
 	int opc;
 	do {
 		cout << "Elige una opción: " << endl;
 		cout << "1 Cargar cuenta de fichero" << endl;
 		cout << "2 Importe de la primera nómina" << endl;
 		cout << "3 Gasto medio de luz en un año" << endl;
 		cout << "4 Mostrar por pantalla" << endl;
 		cout << "0 Salir" << endl;
 		cin >> opc;
 	} while (opc < 0 || opc > 4);
 	return opc;
 }
 void cargar(tCuenta & cuenta, string fichero){
 	ifstream archivo;
 	archivo.open(fichero);
 	int aux;
 	if (archivo.is_open()) {
 		archivo >> aux;
 		while (aux != -1 && cuenta.cont != MAX_APUNTES) {
 			cuenta.apunte[cuenta.cont].fecha.dia = aux;
 			archivo >> cuenta.apunte[cuenta.cont].fecha.mes;
 			archivo >> cuenta.apunte[cuenta.cont].fecha.año;
 			archivo >> cuenta.apunte[cuenta.cont].impor;
 			archivo >> cuenta.apunte[cuenta.cont].concep;
 			archivo >> aux;
 			cuenta.cont++;
 		}
 		archivo.close();
 	}
 	else {
 		cout << "Archivo no encontrado" << endl;
 	}
 }
 void Nomina(const tCuenta cuenta) {
 	float nomina = 0;
 	bool found = false;
 	int i = 0;
 	while (i < cuenta.cont && !found) {
 		if (cuenta.apunte[i].concep == "Salario") {
 			nomina = cuenta.apunte[i].impor;
 			found = true;
 		}
 		else {
 			i++;
 		}
 	}
 	if (nomina != 0) {
 		cout << "El importe de la primera nomina es: " << fixed << setprecision(2) << nomina << " euros." << endl;
 	}
 	else {
 		cout << "No hay salarios" << endl;
 	}
 }
 void GastoLuzAño(const tCuenta cuenta, int año) {
 	float numLuz = 0;
 	float sum = 0;
 	float media = 0;
 	for (int i = 0; i < cuenta.cont; i++) {
 		if (cuenta.apunte[i].fecha.año == año && cuenta.apunte[i].concep == "Luz") {
 			sum += cuenta.apunte[i].impor;
 			numLuz++;
 		}
 	}
 	media = sum / numLuz;
 	media = media * -1;
 	cout << " Gasto medio del año " << año << " es: " << media << endl;
 }
 void mostrar(const tCuenta cuenta) {
 	for (int i = 0; i < cuenta.cont; i++){
 		cout << setfill('0') << setw(2) << internal << cuenta.apunte[i].fecha.dia <<" "
 			 << setw(2) << cuenta.apunte[i].fecha.mes << " "
 			 << setfill(' ') << setw(5) << cuenta.apunte[i].fecha.año
 			 << right << fixed << setprecision(2) << setw(10) << cuenta.apunte[i].impor  << " "
 			 << setw(10) << left << cuenta.apunte[i].concep << " " << endl;
 	}
 }
--- a/G)/ExFeb17AEDG_Fernando.cpp
+++ b/G)/ExFeb17AEDG_Fernando.cpp
@ -0,0 +1,185 @@
 //Examen Febrero 2017 - Grupos: A, E, D y G.
 //Fernando Méndez Torrubiano
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int MAX_APUNTES = 500;
 //Tipos:
 typedef struct {
 	int dia;
 	int mes;
 	int anio;
 }tFecha;
 typedef struct {
 	tFecha fecha;
 	float importe;
 	string concepto;
 }tApunte;
 typedef tApunte tApuntes[MAX_APUNTES];
 typedef struct {
 	tApuntes apunte;
 	int contador;
 }tCuenta;
 //Funciones:
 void inicializa(tCuenta&);
 bool cargar(tCuenta&);
 int menu();
 void ejecutarMenu(tCuenta&);
 float nomina(tCuenta&);
 float gastoLuz(tCuenta&, const int&);
 void mostrar(tCuenta&);
 int main() {
 	tCuenta cuentas;
 	ejecutarMenu(cuentas);
 	return 0;
 }
 void inicializa(tCuenta& cuentas) {
 	cuentas.contador = 0;
 	for (int i = 0; i < MAX_APUNTES; i++) {
 		cuentas.apunte[i].fecha.dia = 0;
 		cuentas.apunte[i].fecha.mes = 0;
 		cuentas.apunte[i].fecha.anio = 0;
 		cuentas.apunte[i].importe = 0;
 		cuentas.apunte[i].concepto = "";
 	}
 }
 bool cargar(tCuenta& cuentas) {
 	bool carga = false;
 	string nombreFichero;
 	ifstream archivo;
 	inicializa(cuentas);
 	cout << "Introduzca nombre del archivo: ";
 	cin >> nombreFichero;
 	nombreFichero += ".txt";
 	archivo.open(nombreFichero);
 	if (!archivo.is_open()) {
 		cout << "Error al cargar el archivo." << endl;
 		carga = false;
 	}
 	else {
 		archivo >> cuentas.apunte[cuentas.contador].fecha.dia;
 		while ((cuentas.apunte[cuentas.contador].fecha.dia != -1) && (cuentas.contador < MAX_APUNTES)) {
 			archivo >> cuentas.apunte[cuentas.contador].fecha.mes;
 			archivo >> cuentas.apunte[cuentas.contador].fecha.anio;
 			archivo >> cuentas.apunte[cuentas.contador].importe;
 			archivo >> cuentas.apunte[cuentas.contador].concepto;
 			cuentas.contador++;
 			archivo >> cuentas.apunte[cuentas.contador].fecha.dia;
 		}
 		carga = true;
 	}
 	archivo.close();
 	return carga;
 }
 int menu() {
 	int opc = 0;
 	cout << setw(35) << setfill('=') << "\n" << setw(0) << setfill(char(0));
 	cout << "1.-Cargar cuenta de fichero." << endl;
 	cout << "2.-Importe de la primera nomina." << endl;
 	cout << "3.-Gasto medio de la luz en un anio." << endl;
 	cout << "4.-Mostrar por pantalla." << endl;
 	cout << "0.-Salir." << endl;
 	cout << setw(35) << setfill('=') << "\n" << setw(0) << setfill(char(0));
 	do {
 		cout << "Introduzca una opcion: ";
 		cin >> opc;
 	} while ((opc < 0) || (opc > 4));
 	return opc;
 }
 void ejecutarMenu(tCuenta& cuentas) {
 	int opc = 1;
 	int anio = 0;
 	while (opc != 0) {
 		opc = menu();
 		switch (opc) {
 		case 1: 
 			if (cargar(cuentas)) { 
 				cout << "Cargado correctamente." << endl; 
 			}
 			else {
 				cout << "Vuelva a intentarlo." << endl; 
 			} break;
 		case 2: cout << "Primera nomina: " << nomina(cuentas) << endl; break;
 		case 3: cout << "Introduzca un anio: ";
 			cin >> anio;
 			cout << "Gasto en " << anio << ": " << gastoLuz(cuentas, anio) << endl; break;
 		case 4: mostrar(cuentas); break;
 		case 0: break;
 		}
 		system("PAUSE");
 		system("cls");
 	}
 }
 float nomina(tCuenta& cuentas) {
 	bool encontrado = false;
 	int i = 0;
 	while ((!encontrado) && (i < cuentas.contador)) {
 		if (cuentas.apunte[i].concepto == "Salario") {
 			encontrado = true;
 		}
 		else {
 			i++;
 		}
 	}
 	return cuentas.apunte[i].importe;
 }
 float gastoLuz(tCuenta& cuentas, const int& anio) {
 	int i = 0;
 	float gasto = 0;
 	float importePositivo = 0;
 	while (i < cuentas.contador) {
 		if ((cuentas.apunte[i].concepto == "Luz") && (cuentas.apunte[i].fecha.anio == anio)) {
 			importePositivo = -1 * cuentas.apunte[i].importe;
 			gasto += importePositivo;
 		}
 		i++;
 	}
 	return gasto;
 }
 void mostrar(tCuenta& cuentas) {
 	cout << "FECHA" << "     " << "IMPORTE" << "  " << right << "CONCEPTO" << endl;
 	cout << setw(35) << setfill('-') << "\n" << setw(0) << setfill(char(0));
 	for (int i = 0; i < cuentas.contador; i++) {
 		cout << cuentas.apunte[i].fecha.dia << "/"
 			<< cuentas.apunte[i].fecha.mes << "/"
 			<< cuentas.apunte[i].fecha.anio << "     "  << left
 			<< cuentas.apunte[i].importe << "  " << right
 			<< cuentas.apunte[i].concepto << endl;
 	}
 	cout << setw(35) << setfill('-') << "\n" << setw(0) << setfill(char(0));
 }
--- a/G)/ExFeb17AEDGv2_Fernando.cpp
+++ b/G)/ExFeb17AEDGv2_Fernando.cpp
@ -0,0 +1,185 @@
 //Examen Febrero 2017 - Grupos A, E, D y G.
 //Fernando Méndez Torrubiano
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int MAX_APUNTES = 500;
 //Tipos:
 typedef struct tFecha {
 	int dia, mes, anio;
 };
 typedef struct tApunte {
 	tFecha fecha;
 	float importe;
 	string concepto;
 };
 typedef tApunte tApuntes[MAX_APUNTES];
 typedef struct tCuenta {
 	tApuntes apunte;
 	int contador;
 };
 //Funciones:
 void inicializa(tCuenta&);
 bool cargar(tCuenta&);
 float nomina(tCuenta&);
 float gastoMedio(tCuenta&, const int&);
 void mostrar(tCuenta&);
 void ejecutarMenu(tCuenta&);
 int menu();
 int main() {
 	tCuenta cuenta;
 	ejecutarMenu(cuenta);
 	return 0;
 }
 void inicializa(tCuenta& cuenta) {
 	cuenta.contador = 0;
 	for (int i = 0; i < MAX_APUNTES; i++){
 		cuenta.apunte[i].fecha.dia = 0;
 		cuenta.apunte[i].fecha.mes = 0;
 		cuenta.apunte[i].fecha.anio = 0;
 		cuenta.apunte[i].importe = 0;
 		cuenta.apunte[i].concepto = "";
 	}
 }
 bool cargar(tCuenta& cuenta) {
 	bool carga = false;
 	ifstream archivo;
 	string nomArchivo;
 	inicializa(cuenta);
 	cout << "Introduzca nombre del archivo (sin extension): ";
 	cin >> nomArchivo;
 	nomArchivo += ".txt";
 	archivo.open(nomArchivo);
 	if (!archivo.is_open()){
 		cout << "Error al cargar el archivo." << endl;
 		carga = false;
 	}
 	else {
 		archivo >> cuenta.apunte[cuenta.contador].fecha.dia;
 		while ((cuenta.apunte[cuenta.contador].fecha.dia != -1) && (cuenta.contador < MAX_APUNTES)) {
 			archivo >> cuenta.apunte[cuenta.contador].fecha.mes;
 			archivo >> cuenta.apunte[cuenta.contador].fecha.anio;
 			archivo >> cuenta.apunte[cuenta.contador].importe;
 			archivo >> cuenta.apunte[cuenta.contador].concepto;
 			cuenta.contador++;
 			archivo >> cuenta.apunte[cuenta.contador].fecha.dia;
 		}
 		carga = true;
 	}
 	archivo.close();
 	return carga;
 }
 float nomina(tCuenta& cuenta) {
 	bool encontrado = false;
 	int i = 0;
 	float nomina = 0;
 	while ((!encontrado) && (i < cuenta.contador)) {
 		if (cuenta.apunte[i].concepto == "Salario") {
 			nomina = cuenta.apunte[i].importe;
 			encontrado = true;
 		}
 		else {
 			i++;
 		}
 	}
 	return nomina;
 }
 float gastoMedio(tCuenta& cuenta, const int& anio) {
 	float gasto = 0;
 	int i = 0;
 	while ((i < cuenta.contador)) {
 		if ((cuenta.apunte[i].fecha.anio == anio) && (cuenta.apunte[i].concepto == "Luz")) {
 			gasto += (-1 * cuenta.apunte[i].importe);
 		}
 		i++;
 	}
 	return gasto;
 }
 void mostrar(tCuenta& cuenta) {
 	cout << setw(2) << right << "DIA"
 		<< setw(5) << "MES"
 		<< setw(10) << "ANIO"
 		<< setw(10) << "IMPORTE"
 		<< setw(15) << "CONCEPTO" << endl;
 	cout << setw(50) << setfill('=') << "\n" << setfill(char(0));
 	for (int i = 0; i < cuenta.contador; i++){
 		cout << setw(2) << right << cuenta.apunte[i].fecha.dia
 			<< setw(5) << cuenta.apunte[i].fecha.mes
 			<< setw(10) << cuenta.apunte[i].fecha.anio
 			<< setw(10) << cuenta.apunte[i].importe
 			<< setw(15) << cuenta.apunte[i].concepto << endl;
 	}
 	cout << setw(50) << setfill('=') << "\n" << setfill(char(0));
 }
 void ejecutarMenu(tCuenta& cuenta) {
 	int opc = 1;
 	float anio;
 	while (opc != 0) {
 		opc = menu();
 		switch (opc){
 		case 0: break;
 		case 1: 
 			if (cargar(cuenta)) {
 				cout << "Cargado correctamente." << endl;
 			}
 			else {
 				cout << "No se ha podido cargar el archivo." << endl;
 			}
 			break;
 		case 2: cout << "El importe de la primera nomina es: " << nomina(cuenta) << endl; break;
 		case 3: 
 			cout << "Introduzca un anio: ";
 			cin >> anio;
 			cout << "El gasto medio de la luz en el anio " << anio << " fue: " << gastoMedio(cuenta, anio) << endl; break;
 		case 4: mostrar(cuenta); break;
 		default:
 			break;
 		}
 		system("PAUSE");
 		system("cls");
 	}
 }
 int menu() {
 	int opc = 0;
 	cout << setw(25) << setfill('=') << "MENU" << setw(25) << "\n" << setfill(char(0));
 	cout << "1.-Cargar cuenta de un fichero." << endl;
 	cout << "2.-Importe de la ultima nomina." << endl;
 	cout << "3.-Gasto medio de luz en un anio." << endl;
 	cout << "4.-Mostrar por pantalla" << endl;
 	cout << "0.-Salir" << endl;
 	cout << setw(50) << setfill('=') <<"\n" << setfill(char(0));
 	do {
 		cout << "Introduzca una opcion: ";
 		cin >> opc;
 	} while (opc < 0 || opc>4);
 	return opc;
 }
--- a/G)/Febrero2017AEDG.pdf
+++ b/G)/Febrero2017AEDG.pdf
--- a/Semestre)/Febrero
+++ b/Semestre)/Febrero
@ -0,0 +1,13 @@
 12 01 2015  500.22 Ingreso
 12 01 2015  1235.45 Salario
 23 01 2015  -324.24 Impuestos
 03 02 2015  -35.00 Transferencia
 04 02 2015  -1214.12 Transferencia
 23 02 2015  -83.15 Luz
 22 03 2015  -20.00 Tarjeta
 12 05 2015  -124.32 Luz
 23 02 2016  -23.54 Luz
 03 03 2016  -20.00 Devolución
 05 03 2016  1111.01 Salario
 05 05 2016  1300.01 Salario
 -1 
--- a/D)/ExFeb17BCD_Fernando.cpp
+++ b/D)/ExFeb17BCD_Fernando.cpp
@ -0,0 +1,258 @@
 //Examen Febrero 2017 - Grupos B, C y D
 //Fernando Méndez Torrubiano
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int N = 10;
 //Tipos:
 typedef struct tEquipo {
 	string nombre;
 	int puntos;
 };
 typedef struct tJornada {
 	string local, visitante;
 	int golesLocal, golesVisitante;
 };
 typedef tEquipo tEquipos[N];
 typedef tJornada tPartidos[N / 2];
 typedef struct tListaEquipos {
 	tEquipos equipo;
 	tPartidos partido;
 	//En este examen no se necesita un contador.
 };
 //Funciones:
 void inicia(tListaEquipos&);
 bool cargarLiga(tListaEquipos&);
 bool cargarJornada(tListaEquipos&);
 void mostrarLiga(tListaEquipos&);
 void mostrarJornada(tListaEquipos&);
 int menu();
 void ejecutarMenu(tListaEquipos&);
 bool actualizarLiga(tListaEquipos&);
 void mostrarPrimero(tListaEquipos&);
 void guardarLiga(tListaEquipos&);
 void ordenar(tListaEquipos&);
 int main() {
 	tListaEquipos equipos;
 	inicia(equipos);
 	if ((cargarLiga(equipos)) && (cargarJornada(equipos))) {
 		ejecutarMenu(equipos);
 		guardarLiga(equipos);
 	}
 	else {
 		cout << "FIN DEL PROGRAMA." << endl;
 		system("PAUSE");
 	}
 	return 0;
 }
 void inicia(tListaEquipos& equipos) {
 	for (int i = 0; i < N; i++){
 		equipos.equipo[i].nombre = "";
 		equipos.equipo[i].puntos = 0;
 		if (i < N / 2) {
 			equipos.partido[i].local = "";
 			equipos.partido[i].visitante = "";
 			equipos.partido[i].golesLocal = 0;
 			equipos.partido[i].golesVisitante = 0;
 		}
 	}
 }
 bool cargarLiga(tListaEquipos& equipos) {
 	bool carga = false;
 	ifstream archivo;
 	archivo.open("liga.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al cargar la liga." << endl;
 		carga = false;
 	}
 	else {
 		for (int i = 0; i < N; i++) {
 			archivo >> equipos.equipo[i].nombre;
 			archivo >> equipos.equipo[i].puntos;
 		}
 		ordenar(equipos);
 		carga = true;
 	}
 	archivo.close();
 	return carga;
 }
 void ordenar(tListaEquipos& equipos) {
 	string auxiliar;
 	int aux, pos;
 	for (int i = 0; i < N; i++) {
 		pos = i;
 		while ((equipos.equipo[pos].puntos > equipos.equipo[pos - 1].puntos) && (pos > 0)) {
 			auxiliar = equipos.equipo[pos].nombre;
 			equipos.equipo[pos].nombre = equipos.equipo[pos - 1].nombre;
 			equipos.equipo[pos - 1].nombre = auxiliar;
 			aux = equipos.equipo[pos].puntos;
 			equipos.equipo[pos].puntos = equipos.equipo[pos - 1].puntos;
 			equipos.equipo[pos - 1].puntos = aux;
 			pos--;
 		}
 	}
 }
 bool cargarJornada(tListaEquipos& equipos) {
 	bool carga = false;
 	ifstream archivo;
 	archivo.open("jornada.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al cargar la jornada." << endl;
 		carga = false;
 	}
 	else {
 		for (int i = 0; i < N / 2; i++) {
 			archivo >> equipos.partido[i].local;
 			archivo >> equipos.partido[i].golesLocal;
 			archivo >> equipos.partido[i].visitante;
 			archivo >> equipos.partido[i].golesVisitante;
 		}
 		carga = true;
 	}
 	archivo.close();
 	return carga;
 }
 void mostrarLiga(tListaEquipos& equipos) {
 	cout << setw(7) << right << "EQUIPO" << setw(15) << right << "PUNTOS" << endl;
 	cout << setfill('=') << setw(25) << "\n" << setfill(char(0)) << setw(0);
 	for (int i = 0; i < N; i++){
 		cout << setw(7) << right << equipos.equipo[i].nombre 
 			<< setw(15) << right << equipos.equipo[i].puntos << endl;
 	}
 	cout << setfill('=') << setw(25) << "\n" << setfill(char(0)) << setw(0);
 }
 void mostrarJornada(tListaEquipos& equipos) {
 	cout << setw(5) << right << "LOCAL" << setw(10) << "GOLES" << setw(20) << "VISITANTE" << setw(10) << "GOLES" << endl;
 	cout << setfill('=') << setw(50) << "\n" << setfill(char(0)) << setw(0);
 	for (int i = 0; i < N/2; i++) {
 		cout << setw(4) << right << equipos.partido[i].local << left
 			<< setw(2) << right << setw(10) << equipos.partido[i].golesLocal << left
 			<< setw(4) << right <<setw(20) << equipos.partido[i].visitante << left
 			<< setw(2) << right <<setw(10) << equipos.partido[i].golesVisitante << endl;
 	}
 	cout << setfill('=') << setw(50) << "\n" << setfill(char(0)) << setw(0);
 }
 int menu() {
 	int opc = 0;
 	cout << setw(35) << setfill('=') << "\n" << setfill(char(0)) << setw(0);
 	cout << "1.-MOSTRAR CLASIFICACION DE LA LIGA." << endl;
 	cout << "2.-MOSTRAR ULTIMA JORNADA." << endl;
 	cout << "3.-ACTUALIZAR LIGA." << endl;
 	cout << "4.-MOSTRAR PRIMER CLASIFICADO." << endl;
 	cout << "0.-SALIR." << endl;
 	cout << setw(35) << setfill('=') << "\n" << setfill(char(0)) << setw(0);
 	do {
 		cout << "Introduzca una opcion: ";
 		cin >> opc;
 	} while (opc < 0 || opc > 4);
 	return opc;
 }
 void ejecutarMenu(tListaEquipos& equipos) {
 	int opc = 1;
 	while (opc != 0) {
 		opc = menu();
 		switch (opc) {
 		case 1: mostrarLiga(equipos); break;
 		case 2: mostrarJornada(equipos); break;
 		case 3: if (actualizarLiga(equipos)) { cout << "ACTUALIZADA CORRECTAMENTE." << endl; }
 				else { cout << "ERROR AL ACTUALIZAR." << endl; } break;
 		case 4: mostrarPrimero(equipos); break;
 		case 0: break;
 		}
 		system("Pause");
 		system("cls");
 	}
 }
 bool actualizarLiga(tListaEquipos& equipos) {
 	bool encontrado = false;
 	int j = 0;
 	for (int i = 0; i < N/2; i++){
 		if (equipos.partido[i].golesLocal > equipos.partido[i].golesVisitante) {
 			j = 0;
 			while (!encontrado && j < N) {
 				if (equipos.equipo[j].nombre == equipos.partido[i].local) {
 					equipos.equipo[j].puntos += 3;
 					encontrado = true;
 				}
 				j++;
 			}
 		}
 		if (equipos.partido[i].golesLocal < equipos.partido[i].golesVisitante) {
 			j = 0;
 			while (!encontrado && j < N) {
 				if (equipos.equipo[j].nombre == equipos.partido[i].visitante) {
 					equipos.equipo[j].puntos += 3;
 				}
 				j++;
 			}
 		}
 		if (equipos.partido[i].golesLocal == equipos.partido[i].golesVisitante) {
 			j = 0;
 			while (j < N) {
 				if (equipos.equipo[j].nombre == equipos.partido[i].local) {
 					equipos.equipo[j].puntos += 1;
 				}
 				if (equipos.equipo[j].nombre == equipos.partido[i].visitante) {
 					equipos.equipo[j].puntos += 1;
 				}
 				j++;
 			}
 			encontrado = true;
 		}
 	}
 	ordenar(equipos);
 	return encontrado;
 }
 void mostrarPrimero(tListaEquipos& equipos) {
 	ordenar(equipos);
 	cout << "Primer equipo en la liga: " << equipos.equipo[0].nombre << " con " << equipos.equipo[0].puntos << " puntos." << endl;
 }
 void guardarLiga(tListaEquipos& equipos) {
 	ofstream archivo;
 	archivo.open("liga.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al guardar los datos." << endl;
 	}
 	else {
 		for (int i = 0; i < N; i++) {
 			archivo << equipos.equipo[i].nombre << " ";
 			archivo << equipos.equipo[i].puntos << endl;
 		}
 	}
 	archivo.close();
 }
--- a/D)/Febrero2017BCD.pdf
+++ b/D)/Febrero2017BCD.pdf
--- a/Semestre)/Febrero
+++ b/Semestre)/Febrero
@ -0,0 +1,5 @@
 ATM 5 Celta 0
 DEP 3 BCN 1
 GET2 4 GET1 4
 RM 0 ZARA 9 
 VAL 1 Sevilla 1
--- a/Semestre)/Febrero
+++ b/Semestre)/Febrero
@ -0,0 +1,10 @@
 CELTA 42
 GET1 13
 ATM 53
 DEP 31
 BCN 53
 GET2 15
 ZARA 16
 Sevilla 13
 VAL 15
 RM 49
--- a/I)/ExFeb18CGIv2_Fernando.cpp
+++ b/I)/ExFeb18CGIv2_Fernando.cpp
@ -0,0 +1,282 @@
 //Examen Febrero 2018 - Grupos C, G e I
 //Fernando Méndez Torrubiano
 //Versión 2
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int MAX_NAV = 24;
 //Tipos:
 typedef struct tNavio {
 	string nombre;
 	string empresa;
 	float eslora;
 	float toneladas;
 	bool peaje;
 };
 typedef tNavio tNavios[MAX_NAV];
 typedef struct tListaNavios {
 	tNavios navio;
 	int contador;
 };
 //Funciones:
 void inicializa(tListaNavios&);
 bool cargar(tListaNavios&);
 void muestraNavios(tListaNavios&);
 bool crearNavio(tListaNavios&);
 bool insertarNavio(tListaNavios&, tNavio&);
 bool cobrarNavio(tListaNavios&, const string&);
 float peajeNavio(tListaNavios&, const int&);
 float peajePagado(tListaNavios&);
 void ejecutarMenu(tListaNavios&);
 int menu();
 bool guardar(tListaNavios&);
 int main() {
 	tListaNavios navios;
 	if (cargar(navios)) {
 		ejecutarMenu(navios);
 		if (guardar(navios)) {
 			cout << "Guardado correctamente." << endl;
 		}
 		else {
 			cout << "Error al guardar el archivo." << endl;
 		}
 	}
 	else {
 		cout << "Fin del programa." << endl;
 	}
 	return 0;
 }
 void inicializa(tListaNavios& navios) {
 	navios.contador = 0;
 	for (int i = 0; i < MAX_NAV; i++){
 		navios.navio[i].nombre = "";
 		navios.navio[i].empresa = "";
 		navios.navio[i].eslora = 0;
 		navios.navio[i].toneladas = 0;
 		navios.navio[i].peaje = false;
 	}
 }
 bool cargar(tListaNavios& navios) {
 	bool cargado = false;
 	ifstream archivo;
 	string aux = "";
 	inicializa(navios);
 	archivo.open("navios.txt");
 	if(!archivo.is_open()){
 		cout << "No se ha podido cargar el archivo." << endl;
 		cargado = false;
 	}
 	else {
 		archivo >> navios.navio[navios.contador].nombre;
 		while ((navios.navio[navios.contador].nombre != "XXX") && (navios.contador < MAX_NAV)) {
 			archivo >> navios.navio[navios.contador].empresa;
 			archivo >> navios.navio[navios.contador].eslora;
 			archivo >> navios.navio[navios.contador].toneladas;
 			archivo >> aux;
 			if (aux == "true") {
 				navios.navio[navios.contador].peaje = true;
 			}
 			else {
 				navios.navio[navios.contador].peaje = false;
 			}
 			navios.contador++;
 			archivo >> navios.navio[navios.contador].nombre;
 		}
 		cargado = true;
 	}
 	archivo.close();
 	return cargado;
 }
 void muestraNavios(tListaNavios& navios) {
 	cout << setw(15) << right << "NOMBRE"
 		<< setw(20) << "EMPRESA"
 		<< setw(10) << "ESLORA"
 		<< setw(15) << "TONELADAS"
 		<< setw(25) << "PEAJE" << endl;
 	cout << setw(100) << setfill('=') << "\n" << setfill(char(0));
 	for (int i = 0; i < navios.contador; i++){
 		cout << setw(15) << right << navios.navio[i].nombre
 			<< setw(20) << navios.navio[i].empresa
 			<< setw(10) << fixed << setprecision(2) << navios.navio[i].eslora
 			<< setw(15) <<  setprecision(2) << navios.navio[i].toneladas;
 		cout << setw(10) << peajeNavio(navios, i) << "$" << setw(12);
 		if (navios.navio[i].peaje == true) {
 			cout << "PAGADO." << endl;
 		}
 		else {
 			cout << "NO PAGADO." << endl;
 		}
 	}
 	cout << setw(100) << setfill('=') << "\n" << setfill(char(0));
 	cout << "Total pagado: " << peajePagado(navios) << endl;
 }
 bool crearNavio(tListaNavios& navios) {
 	tNavio nuevoNavio;
 	cout << "Introduzca nombre del navio: ";
 	cin >> nuevoNavio.nombre;
 	cout << "Introduzca empressa fabricante: ";
 	cin >> nuevoNavio.empresa;
 	cout << "Introduzca eslora (en metros): ";
 	cin >> nuevoNavio.eslora;
 	cout << "Introduzca toneladas de carga: ";
 	cin >> nuevoNavio.toneladas;
 	nuevoNavio.peaje = false;
 	return insertarNavio(navios, nuevoNavio);
 }
 bool insertarNavio(tListaNavios& navios, tNavio& nuevoNavio) {
 	if (navios.contador < MAX_NAV){
 		navios.navio[navios.contador].nombre = nuevoNavio.nombre;
 		navios.navio[navios.contador].empresa = nuevoNavio.empresa;
 		navios.navio[navios.contador].eslora = nuevoNavio.eslora;
 		navios.navio[navios.contador].toneladas = nuevoNavio.toneladas;
 		navios.navio[navios.contador].peaje = nuevoNavio.peaje;
 		navios.contador++;
 	}
 	return (navios.contador < MAX_NAV) ? true : false;
 }
 bool cobrarNavio(tListaNavios& navios, const string& nombre) {
 	int i = 0;
 	bool encontrado = false;
 	while ((!encontrado) && (i <= navios.contador)) {
 		if (navios.navio[i].nombre == nombre) {
 			navios.navio[i].peaje = true;
 			encontrado = true;
 		}
 		else {
 			i++;
 		}
 	}
 	return (navios.navio[i].nombre == nombre) ? true : false;
 }
 float peajeNavio(tListaNavios& navios, const int& pos) {
 	float pago = 0;
 	if (navios.navio[pos].eslora <= 100) {
 		pago = navios.navio[pos].toneladas * 2;
 	}
 	else {
 		pago = navios.navio[pos].toneladas * 3;
 	}
 	return pago;
 }
 float peajePagado(tListaNavios& navios) {
 	float total = 0;
 	for (int i = 0; i < navios.contador; i++){
 		if (navios.navio[i].peaje == true) {
 			total += peajeNavio(navios, i);
 		}
 	}
 	return total;
 }
 void ejecutarMenu(tListaNavios& navios) {
 	int opc = 1;
 	string nombre;
 	while (opc != 0){
 		opc = menu();
 		switch (opc){
 		case 0: break;
 		case 1: muestraNavios(navios); break;
 		case 2: 
 			if (crearNavio(navios)) {
 				cout << "Insertado correctamente." << endl;
 			}
 			else {
 				cout << "Error al insertar." << endl;
 			} 
 			break;
 		case 3: 
 			cout << "Introduzca el nombre del navio a cobrar: ";
 			cin >> nombre;
 			if (cobrarNavio(navios, nombre)) {
 				cout << "Cobrado." << endl;
 			}
 			else {
 				cout << "Navio no encontrado." << endl;
 			}
 			break;
 		default:
 			break;
 		}
 		system("PAUSE");
 		system("cls");
 	}
 }
 int menu() {
 	int opc = 0;
 	cout << setw(20) << setfill('=') << "MENU" << setw(20) << "\n" << setfill(char(0));
 	cout << "1.-Mostrar navios." << endl;
 	cout << "2.-Insertar nuevo navio." << endl;
 	cout << "3.-Realizar pago." << endl;
 	cout << setw(40) << setfill('=') << "\n" << setfill(char(0));
 	do {
 		cout << "Introduzca una opcion: ";
 		cin >> opc;
 	} while (opc < 0 || opc > 4);
 	return opc;
 }
 bool guardar(tListaNavios& navios) {
 	bool guardado = false;
 	ofstream archivo;
 	archivo.open("navios.txt");
 	if(!archivo.is_open()){
 		cout << "Error al guardar." << endl;
 		guardado = false;
 	}
 	else {
 		for (int i = 0; i < navios.contador; i++){
 			archivo << navios.navio[i].nombre << " "
 				<< navios.navio[i].empresa << " "
 				<< navios.navio[i].eslora << " "
 				<< navios.navio[i].toneladas << " ";
 			if (navios.navio[i].peaje == true) {
 				archivo << "true" << endl;
 			}
 			else {
 				archivo << "false" << endl;
 			}
 		}
 		archivo << "XXX";
 		guardado = true;
 	}
 	archivo.close();
 	return guardado;
 }
--- a/I)/ExFeb18_Eva.cpp
+++ b/I)/ExFeb18_Eva.cpp
@ -0,0 +1,215 @@
 /*
 Apellidos: Verdú Rodríguez
 Nombre: Eva
 DNI: 51220965B
 Puesto: 15
 */
 #include <iostream>
 #include <fstream>
 #include <string>
 #include <iomanip> 
 using namespace std;
 //Constantes:
 const int MAX_NAV = 24;
 const string CENT = "XXX";
 typedef struct tNavios{
 	string nom;
 	string empr;
 	float esl;
 	float ton;
 	string pag;
 };
 typedef tNavios tListaNav[MAX_NAV];
 typedef struct tListaNavios {
 	tListaNav lista;
 	int cont;
 };
 //Funciones:
 int menu();
 bool cargar(tListaNavios & lista); //Carga el archivo.
 void muestraNavios(const tListaNavios lista);
 float peajeNavio(const tNavios navio);
 float peajePagado(const tListaNavios lista);
 void crearNavio(tListaNavios & lista);
 bool insertaNavio(const tNavios navio, tListaNavios & lista);
 bool cobrarNavio(tListaNavios & lista, string name);
 int main() {
 	tListaNavios lista;
 	string name;
 	bool cobrar = true;
 	bool ok = cargar(lista);
 	int opc=0;
 	if (ok) {
 		do{
 			opc = menu();
 			switch (opc) {
 			case 1:
 				muestraNavios(lista);
 				break;
 			case 2:
 				crearNavio(lista);
 				break;
 			case 3:
 				cout << "Introduce Nombre del Navio: ";
 				cin >> name;
 				cobrar = cobrarNavio(lista , name);
 				if (!cobrar) {
 					cout << "Error. Barco no encontrado" << endl;
 				}
 				break;
 			}
 		} while (opc != 0);
 	}
 	else {
 		cout << "Error al abrir el archivo" << endl;
 	}
 	system("pause");
 	return 0;
 }
 int menu() {
 	int opc;
 	cout << "---------------------------------" << endl;
 	cout << "Elige una opcion: " << endl;
 	cout << "1 - Muestra la lista" << endl;
 	cout << "2 - Nuevo navio" << endl;
 	cout << "3 - Pagar navio" << endl;
 	cout << "0 - Salir" << endl;
 	cout << "---------------------------------" << endl;
 	cin >> opc;
 	while (opc < 0 || opc > 3) {
 		cout << "Error. Ponga un valor entre 0 y 3." << endl;
 	}
 	return opc;
 }
 bool cargar(tListaNavios & lista){
 	bool ok = true;
 	string aux;
 	ifstream archivo;
 	lista.cont = 0;
 	archivo.open("navios.txt");
 	if (archivo.is_open()) {
 		archivo >> lista.lista[lista.cont].nom;
 		while((lista.lista[lista.cont].nom != CENT) && (lista.cont < MAX_NAV)) {
 			archivo >> lista.lista[lista.cont].empr;
 			archivo >> lista.lista[lista.cont].esl;
 			archivo >> lista.lista[lista.cont].ton;
 			archivo >> lista.lista[lista.cont].pag;
 			lista.cont++;
 			archivo >> lista.lista[lista.cont].nom;
 		}
 		archivo.close();
 	}
 	else {
 		ok = false;
 	}
 	return ok;
 }
 void muestraNavios(const tListaNavios lista) {
 	int i = 0;
 	float peaje = 0;
 	cout << "Navio" << setw(20) << "Empresa" << setw(20) << "Eslora" << setw(20) << "Toneladas" << setw(20) << "Peaje" << setw(20) << endl;
 	cout << setw(100) << setfill('=') << "\n";
 	cout << setw(100) << setfill(' ') << "\n";
 	for (int i = 0; i < lista.cont; i++){
 		cout << setw(20) << left << lista.lista[i].nom;
 		cout << setw(20) << lista.lista[i].empr;
 		cout << fixed << setprecision(2) << setw(15) << lista.lista[i].esl;
 		cout << setw(15) << lista.lista[i].ton;
 		peaje = peajeNavio(lista.lista[i]);
 		if (lista.lista[i].pag == "true") {
 			cout << setw(10) << right << peaje  << " Pagado"  << endl;
 		}
 		else {
 			cout << setw(10) << right << peaje << " No Pagado" << endl;
 		}
 	}
 	cout << setw(100) << setfill('=') << '\n';
 	float total = peajePagado(lista);
 	cout << "Precio total: " << total << endl;
 	cout << setw(100) << setfill(' ') << '\n';
 }
 float peajeNavio(const tNavios navio) {
 	float peaje;
 	if (navio.esl < 100) {
 		peaje = navio.ton * 2;
 	}
 	else {
 		peaje = navio.ton * 3;
 	}
 	return peaje;
 }
 float peajePagado(const tListaNavios lista) {
 	float total = 0;
 	for (int i = 0; i < lista.cont; i++){
 		if (lista.lista[i].pag == "true") {
 			float peaje = peajeNavio(lista.lista[i]);
 			total += peaje;
 		}
 	}
 	return total;
 }
 void crearNavio(tListaNavios & lista) {
 	tNavios navio;
 	cout << "Introduzca nombre: ";
 	cin >> navio.nom;
 	cout << "Introduzca compañia: ";
 	cin >> navio.empr;
 	cout << "Introduzca eslora: ";
 	cin >> navio.esl;
 	cout << "Introduzca tonaledas: ";
 	cin >> navio.ton;
 	navio.pag = "false";
 	if (insertaNavio(navio, lista)) {
 		cout << "Se ha insertado correctamente" << endl;
 		cout << setw(100) << setfill(' ') << '\n';
 	}
 	else {
 		cout << "No se pudo introducir" << endl;
 		cout << setw(100) << setfill(' ') << '\n';
 	}
 }
 bool insertaNavio(const tNavios navio, tListaNavios & lista) {
 	bool insertar = true;;
 	if (lista.cont < MAX_NAV) {
 		lista.lista[lista.cont].nom = navio.nom;
 		lista.lista[lista.cont].empr = navio.empr;
 		lista.lista[lista.cont].esl = navio.esl;
 		lista.lista[lista.cont].ton = navio.ton;
 		lista.lista[lista.cont].pag = navio.pag;
 		lista.cont++;
 	}
 	else {
 		insertar = false;
 	}
 	return insertar;
 }
 bool cobrarNavio(tListaNavios & lista, string name) {
 	bool cobrar = false;
 	int i = 0;
 	while (!cobrar && i < lista.cont ) {
 		if (lista.lista[i].nom == name) {
 			lista.lista[i].pag = "true";
 			cobrar = true;
 		}
 		i++;
 	}
 	return cobrar;
 }
--- a/I)/ExFeb18_Fernando.cpp
+++ b/I)/ExFeb18_Fernando.cpp
@ -0,0 +1,262 @@
 //Examen Febreo 2018
 //Fernando Méndez Torrubiano
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int MAX_NAV = 24;
 //Tipos:
 typedef string tNombres[MAX_NAV];
 typedef float tMedidas[MAX_NAV];
 typedef struct tNavios {
 	tNombres nombre;
 	tNombres empresa;
 	tMedidas eslora;
 	tMedidas toneladas;
 	tNombres peaje;
 	int contador;
 };
 //Funciones:
 void inicializa(tNavios&, tNavios&);
 bool cargar(tNavios&);
 void ejecutarMenu(tNavios&, tNavios&);
 int menu();
 void muestraNavios(tNavios&);
 void crearNavio(tNavios&);
 bool insertarNavio(tNavios&, tNavios&);
 bool cobrarNavio(tNavios&);
 float peajeNavio(tNavios&, const int pos);
 float peajePagado(tNavios&);
 void guardar(tNavios&);
 int main() {
 	tNavios nave;
 	tNavios nuevo;
 	bool carga = false;
 	inicializa(nave, nuevo);
 	carga = cargar(nave);
 	if (carga) {
 		ejecutarMenu(nave, nuevo);
 	}
 	else {
 		system("PAUSE");
 	}
 	guardar(nave);
 	return 0;
 }
 void inicializa(tNavios& nave, tNavios& nuevo) {
 	for (int i = 0; i < MAX_NAV; i++) {
 		nave.nombre[i] = "";
 		nave.empresa[i] = "";
 		nave.eslora[i] = 0;
 		nave.toneladas [i]= 0;
 		nave.peaje[i] = "";
 	}
 	nave.contador = 0;
 	nuevo.contador = 0;
 }
 bool cargar(tNavios& nave) {
 	ifstream archivo;
 	bool carga = false;
 	archivo.open("navios.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al cargar el archivo." << endl;
 		carga = false;
 	}
 	else {
 		archivo >> nave.nombre[nave.contador];
 		while ((nave.nombre[nave.contador] != "XXX") && (nave.contador < MAX_NAV)) {
 			archivo >> nave.empresa[nave.contador];
 			archivo >> nave.eslora[nave.contador];
 			archivo >> nave.toneladas[nave.contador];
 			archivo >> nave.peaje[nave.contador];
 			nave.contador++;
 			archivo >> nave.nombre[nave.contador];
 		} 
 		carga = true;
 	}
 	archivo.close();
 	return carga;
 }
 void ejecutarMenu(tNavios& nave, tNavios& nuevo) {
 	int opc = 1;
 	bool insertado = false;
 	while (opc != 0) {
 		system("cls");
 		opc = menu();
 		switch (opc){
 		case 1: muestraNavios(nave); break;
 		case 2: crearNavio(nuevo); 
 				insertado = insertarNavio(nave, nuevo);
 				if (!insertado) {
 					cout << "No se ha podido añadir un nuevo navio." << endl;
 					system("PAUSE");
 				}
 				else{
 					cout << "Navio insertado correctamente." << endl;
 					system("PAUSE");
 				}
 				break;
 		case 3: cobrarNavio(nave); break;
 		case 0: break;
 		default: break;
 		}
 	}
 }
 int menu() {
 	int opc = 0;
 	//cout << setfill('-') << setw(25) << "\n";
 	cout << "1.-VER LISTA DE NAVIOS." << "\n";
 	cout << "2.-AGREGAR NAVIO." << "\n";
 	cout << "3.-COBRAR PEAJE." << "\n";
 	cout << "0.-SALIR." << "\n";
 	//cout << setfill('-') << setw(25) << "\n";
 	do{
 		cout << "\n Intruduzca una opcion: ";
 		cin >> opc;
 	} while ((opc < 0) || (opc > 3));
 	return opc;
 }
 void muestraNavios(tNavios& nave) {
 	cout << setfill(char(0))  << setw(15)
 		<< left << "NOMBRE" << setw(15)
 		<< left << "EMPRESA" << setw(15)
 		<< left << "ESLORA" << setw(20)
 		<< left << "DESPLAZAMIENTO" << setw(20)
 		<< left << "PEAJE";
 	cout << setw(85) << setfill('=') << "\n" << setfill(char(0)) << endl;
 	for (int i = 0; i < nave.contador; i++) {
 		cout << setw(15) << left << nave.nombre[i] << setw(15)
 			<< left << nave.empresa[i] << setw(15)
 			<< left  << fixed << setprecision(2) << nave.eslora[i] << setw(20)
 			<< left << nave.toneladas[i] << setw(10);
 			if (nave.peaje[i] == "true") {
 				cout << peajeNavio(nave, i) << "PAGADO\n";
 			}
 			else {
 				cout << peajeNavio(nave, i) << "NO PAGADO\n";
 			}
 	}
 	cout << setw(85) << setfill('=') << "\n";
 	cout << setw(0) << setfill(char(0)) << "\n";
 	system("PAUSE");
 }
 void crearNavio(tNavios& nuevo) {
 	string nombre;
 	nuevo.contador++;
 	cout << "Introduzca NOMBRE del navio: ";
 	cin >> nuevo.nombre[nuevo.contador];
 	cout << "Introduzca EMPRESA fabricante: ";
 	cin >> nuevo.empresa[nuevo.contador];
 	cout << "Introduzca ESLORA del navio: ";
 	cin >> nuevo.eslora[nuevo.contador];
 	cout << "Introduzca TONELADAS del navio: ";
 	cin >> nuevo.toneladas[nuevo.contador];
 	cout << "Introduzca PEAJE (true/false): ";
 	cin >> nuevo.peaje[nuevo.contador];
 }
 bool insertarNavio(tNavios& nave, tNavios& nuevo) {
 	bool insertado = false;
 	if (nave.contador < MAX_NAV) {
 		nave.nombre[nave.contador] = nuevo.nombre[nuevo.contador];
 		nave.empresa[nave.contador] = nuevo.empresa[nuevo.contador];
 		nave.eslora[nave.contador] = nuevo.eslora[nuevo.contador];
 		nave.toneladas[nave.contador] = nuevo.toneladas[nuevo.contador];
 		nave.peaje[nave.contador] = nuevo.peaje[nuevo.contador];
 		nave.contador++;
 		insertado = true;
 	}
 	else {
 		insertado = false;
 	}
 	return insertado;
 }
 bool cobrarNavio(tNavios& nave) {
 	bool encontrado = false;
 	string nom;
 	int i = 0;
 	cout << "Introduzca el nombre del navio que quiere pagar: ";
 	cin >> nom;
 	while ((i < nave.contador) && (!encontrado)) {
 		if (nave.nombre[i] == nom) {
 			nave.peaje[i] = "true";
 			encontrado = true;
 		}
 		i++;
 	}
 	return encontrado;
 }
 float peajeNavio(tNavios& nave, const int pos) {
 	float precio = 0;
 	if (nave.eslora[pos] <= 100) {
 		precio = nave.toneladas[pos] * 2;
 	}
 	else {
 		precio = nave.toneladas[pos] * 3;
 	}
 	return precio;
 }
 float peajePagado(tNavios& nave) {
 	float pagos = 0;
 	for (int i = 0; i < nave.contador; i++) {
 		if (nave.peaje[i] == "true") {
 			pagos += peajeNavio(nave, i);
 		}
 	}
 	return pagos;
 }
 void guardar(tNavios& nave) {
 	ofstream archivo;
 	archivo.open("navios.txt");
 	if(archivo.is_open()){
 		for (int i = 0; i < nave.contador; i++) {
 			archivo << nave.nombre[i] << " ";
 			archivo << nave.empresa[i] << " ";
 			archivo << nave.eslora[i] << " ";
 			archivo << nave.toneladas[i] << " ";
 			archivo << nave.peaje[i] << " " << endl;
 		}
 		archivo << "XXX";
 	}
 	archivo.close();
 }
--- a/I)/Febrero2018gruposCGI.pdf
+++ b/I)/Febrero2018gruposCGI.pdf
--- a/Semestre)/Febrero
+++ b/Semestre)/Febrero
@ -0,0 +1,6 @@
 Prestill pocoImporta 90 2634 true
 Pluton CAMPSA 104.2 2852 false
 CostaArrecife Costa 337 183900 false
 USSuranus UnitedFruit 82.14 3348 true
 Dedalo ArmadaEspanola 190 13000 false
 XXX
--- a/Semestre)/FrEnero
+++ b/Semestre)/FrEnero
--- a/Semestre)/FrEnero
+++ b/Semestre)/FrEnero
--- a/Semestre)/FrEnero
+++ b/Semestre)/FrEnero
--- a/Semestre)/FrEnero
+++ b/Semestre)/FrEnero
--- a/Semestre)/FrEnero
+++ b/Semestre)/FrEnero
--- a/Semestre)/FrEnero
+++ b/Semestre)/FrEnero
--- a/G)/ExEne19ABDG_Fernando.cpp
+++ b/G)/ExEne19ABDG_Fernando.cpp
@ -0,0 +1,238 @@
 //Examen Enero 2019 - Grupos A, B, D y G.
 //Fernando Méndez Torrubiano
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int MAX_PEDIDOS = 50;
 //Tipos:
 typedef struct tPedido {
 	string numPedido, nombreCliente, direccion, codRepartidor;
 	bool estado;
 };
 typedef tPedido tPedidos[MAX_PEDIDOS];
 typedef struct tListaPedidos {
 	tPedidos pedido;
 	int contador;
 };
 //Funciones:
 void inicializa(tListaPedidos&);
 bool cargar(tListaPedidos&);
 bool actualizarPedido(tListaPedidos&, const string&);
 void mostrarPedidos(tListaPedidos&);
 int posicionRepartidor(tListaPedidos&, const string&);
 void mostrarPedidosRepartidor(tListaPedidos&, const string&);
 bool guardarPedidos(tListaPedidos&);
 void ejecutarMenu(tListaPedidos&);
 int menu();
 int main() {
 	tListaPedidos pedidos;
 	if (cargar(pedidos)) {
 		ejecutarMenu(pedidos);
 		if (guardarPedidos(pedidos)) {
 			cout << "Guardado correctamente." << endl;
 		}
 		else {
 			cout << "Error al guardar." << endl;
 		}
 	}
 	else {
 		cout << "Fin del programa." << endl;
 	}
 	system("PAUSE");
 	return 0;
 }
 void inicializa(tListaPedidos& pedidos) {
 	pedidos.contador = 0;
 	for (int i = 0; i < MAX_PEDIDOS; i++){
 		pedidos.pedido[i].numPedido = "";
 		pedidos.pedido[i].nombreCliente = "";
 		pedidos.pedido[i].direccion = "";
 		pedidos.pedido[i].codRepartidor = "";
 		pedidos.pedido[i].estado = false;
 	}
 }
 bool cargar(tListaPedidos& pedidos) {
 	bool carga = false;
 	ifstream archivo;
 	inicializa(pedidos);
 	archivo.open("pedidos.txt");
 	if (!archivo.is_open()) {
 		cout << "No se ha podido cargar el archivo." << endl;
 		carga = false;
 	}
 	else {
 		while ((!archivo.eof()) && (pedidos.contador < MAX_PEDIDOS)) {
 			getline(archivo, pedidos.pedido[pedidos.contador].numPedido);
 			getline(archivo, pedidos.pedido[pedidos.contador].nombreCliente);
 			getline(archivo, pedidos.pedido[pedidos.contador].direccion);
 			getline(archivo, pedidos.pedido[pedidos.contador].codRepartidor);
 			pedidos.contador++;
 		}
 		carga = true;
 	}
 	archivo.close();
 	return carga;
 }
 bool actualizarPedido(tListaPedidos& pedidos, const string& numPedido) {
 	bool encontrado = false;
 	int i = 0;
 	while ((!encontrado) && (i < pedidos.contador)) {
 		if (pedidos.pedido[i].numPedido == numPedido) {
 			pedidos.pedido[i].estado = true;
 			encontrado = true;
 		}
 		else {
 			i++;
 		}
 	}
 	return encontrado;
 }
 void mostrarPedidos(tListaPedidos& pedidos) {
 	cout << setw(15) << right << "NUMERO PEDIDO"
 		<< setw(25) << "CLIENTE"
 		<< setw(40) << "DIRECCION"
 		<< setw(15) << "REPARTIDOR"
 		<< setw(15) << "ESTADO" << endl;
 	cout << setw(115) << setfill('=') << "\n" << setfill(char(0));
 	for (int i = 0; i < pedidos.contador-1; i++) {
 		cout << setw(15) << right << pedidos.pedido[i].numPedido
 			<< setw(25) << pedidos.pedido[i].nombreCliente
 			<< setw(40) << pedidos.pedido[i].direccion
 			<< setw(15) << pedidos.pedido[i].codRepartidor;
 		if (pedidos.pedido[i].estado == true) {
 			cout << setw(15) << "ENTREGADO" << endl;
 		}
 		else {
 			cout << setw(15) << "PENDIENTE" << endl;
 		}
 	}
 	cout << setw(115) << setfill('=') << "\n" << setfill(char(0));
 }
 int posicionRepartidor(tListaPedidos& pedidos, const string& codRepartidor) {
 	int pos = 0;
 	bool encontrado = false;
 	while ((!encontrado) && (pos <= pedidos.contador)) {
 		if (pedidos.pedido[pos].codRepartidor == codRepartidor) {
 			encontrado = true;
 		}
 		else {
 			pos++;
 		}
 	}
 	return pos;
 }
 void mostrarPedidosRepartidor(tListaPedidos& pedidos, const string& codRepartidor) {
 	int pos = posicionRepartidor(pedidos, codRepartidor);
 	if (pos < pedidos.contador) {
 		cout << endl << "Pedidos pendientes del repartidor: " << codRepartidor << endl;
 		cout << setw(70) << setfill('=') << "\n" << setfill(char(0));
 		cout << "Numero de pedido: " << pedidos.pedido[pos].numPedido << endl;
 		cout << "Cliente: " << pedidos.pedido[pos].nombreCliente << endl;
 		cout << "Direccion de entrega: " << pedidos.pedido[pos].direccion << endl;
 		cout << setw(70) << setfill('=') << "\n" << setfill(char(0));
 	}
 	else {
 		cout << "Repartidor no encontrado." << endl;
 	}
 }
 bool guardarPedidos(tListaPedidos& pedidos) {
 	bool save = false;
 	ofstream archivo;
 	archivo.open("pendientes.txt");
 	if (!archivo.is_open()) {
 		save = false;
 	}
 	else {
 		for (int i = 0; i < pedidos.contador; i++){
 			if (pedidos.pedido[i].estado == false) {
 				archivo << pedidos.pedido[i].numPedido << endl
 					<< pedidos.pedido[i].nombreCliente << endl
 					<< pedidos.pedido[i].direccion << endl
 					<< pedidos.pedido[i].codRepartidor << endl;
 			}
 		}
 		save = true;
 	}
 	archivo.close();
 	return save;
 }
 void ejecutarMenu(tListaPedidos& pedidos) {
 	int opc = 1;
 	string codRepartidor, numPedido;
 	while (opc != 0) {
 		opc = menu();
 		switch (opc) {
 		case 0: break;
 		case 1:  
 			cout << "Codigo de repartidor: ";
 			cin >> codRepartidor;
 			mostrarPedidosRepartidor(pedidos, codRepartidor);
 			system("PAUSE"); 
 			break;
 		case 2: mostrarPedidos(pedidos); system("PAUSE"); break;
 		case 3: 
 			cout << "Introduzca numero de pedido: ";
 			cin >> numPedido;
 			if (actualizarPedido(pedidos, numPedido)) {
 				cout << "Pedido " << numPedido << " actualizado correctamente." << endl;
 			}
 			else {
 				cout << "Pedido no encontrado." << endl;
 			}
 			system("PAUSE"); 
 			break;
 		default:
 			break;
 		}
 		system("cls");
 	}
 }
 int menu() {
 	int opc = 0;
 	cout << setw(20) << setfill('=') << "MENU" << setw(20) << "\n" << setfill(char(0));
 	cout << "1.-Mostrar todos los pedidos pendientes de un repartidor." << endl;
 	cout << "2.-Mostrar todos los pedidos." << endl;
 	cout << "3.-Registro pedido entregado." << endl;
 	cout << "0.-Salir." << endl;
 	cout << setw(40) << setfill('=') << "\n" << setfill(char(0));
 	do {
 		cout << "Introduzca una opcion: ";
 		cin >> opc;
 	} while (opc < 0 || opc > 3);
 	return opc;
 }
--- a/Semestre)/FrEnero
+++ b/Semestre)/FrEnero
@ -0,0 +1,20 @@
 3421
 Pilar Gil
 Paseo Delicias 52 28046 Madrid
 R7689
 12345
 Carlos Campos
 Plaza del Carmen 14 28004 Madrid
 R7689
 5284
 Carmen Santos
 Padilla 6 28001 Madrid
 R9876
 15289
 Carlos Camacho
 Plaza del Carmen 14 28004 Madrid
 R9876
 34210
 Pilar Alcocer
 Paseo Delicias 52 28046 Madrid
 R7000
--- a/I)/ExEne19DEI_Fernando.cpp
+++ b/I)/ExEne19DEI_Fernando.cpp
@ -0,0 +1,258 @@
 //Examen Enero 2019 - Grupos D, E e I.
 //Fernando Méndez Torrubiano
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <iomanip>
 using namespace std;
 //Constantes:
 const int MAX_MILI = 50;
 const int MAX_SUB = 24;
 //Tipos:
 typedef struct tTiempo {
 	int horas, minutos, segundos, milisegundos;
 };
 typedef struct tSubtitulo {
 	tTiempo tiempoIni, tiempoFin;
 	string subtitulo;
 };
 typedef tSubtitulo tSubtitulos[MAX_SUB];
 typedef struct tListaSub {
 	tSubtitulos subtitulo;
 	int contador;
 };
 //Funciones:
 void inicializa(tListaSub&);
 bool cargar(tListaSub&);
 int toMilisegundos(tTiempo&);
 int desajuste(const string&, const int&);
 void mostrar(tListaSub&);
 void cambiarTexto(tListaSub&);
 void buscar(tListaSub&);
 bool buscarMili(tListaSub&, const int&, int&);
 bool guardar(tListaSub&);
 void ejecutarMenu(tListaSub&);
 int menu();
 int main() {
 	tListaSub subtitulos;
 	system("chcp 1252");
 	system("cls");
 	if (cargar(subtitulos)) {
 		ejecutarMenu(subtitulos);
 		if (guardar(subtitulos)) {
 			cout << "Guardado correctamente." << endl;
 		}
 		else {
 			cout << "Error al guardar." << endl;
 		}
 	}
 	else {
 		cout << "Fin del programa." << endl;
 	}
 	system("PAUSE");
 	return 0;
 }
 void inicializa(tListaSub& subtitulos) {
 	subtitulos.contador = 0;
 	for (int i = 0; i < MAX_SUB; i++){
 		subtitulos.subtitulo[i].tiempoIni.horas = 0;
 		subtitulos.subtitulo[i].tiempoIni.minutos = 0;
 		subtitulos.subtitulo[i].tiempoIni.segundos = 0;
 		subtitulos.subtitulo[i].tiempoIni.milisegundos = 0;
 		subtitulos.subtitulo[i].tiempoFin.horas = 0;
 		subtitulos.subtitulo[i].tiempoFin.minutos = 0;
 		subtitulos.subtitulo[i].tiempoFin.segundos = 0;
 		subtitulos.subtitulo[i].tiempoFin.milisegundos = 0;
 		subtitulos.subtitulo[i].subtitulo = "";
 	}
 }
 bool cargar(tListaSub& subtitulos) {
 	bool cargado = false;
 	ifstream archivo;
 	inicializa(subtitulos);
 	archivo.open("subtitulos.txt");
 	if (!archivo.is_open()) {
 		cout << "Error al cargar el archivo." << endl;
 		cargado = false;
 	}
 	else {
 		while ((!archivo.eof()) && (subtitulos.contador < MAX_SUB)) {
 			archivo >> subtitulos.subtitulo[subtitulos.contador].tiempoIni.horas;
 			archivo.ignore();
 			archivo >> subtitulos.subtitulo[subtitulos.contador].tiempoIni.minutos;
 			archivo.ignore();
 			archivo >> subtitulos.subtitulo[subtitulos.contador].tiempoIni.segundos;
 			archivo.ignore();
 			archivo >> subtitulos.subtitulo[subtitulos.contador].tiempoIni.milisegundos;
 			archivo.ignore();
 			archivo >> subtitulos.subtitulo[subtitulos.contador].tiempoFin.horas;
 			archivo.ignore();
 			archivo >> subtitulos.subtitulo[subtitulos.contador].tiempoFin.minutos;
 			archivo.ignore();
 			archivo >> subtitulos.subtitulo[subtitulos.contador].tiempoFin.segundos;
 			archivo.ignore();
 			archivo >> subtitulos.subtitulo[subtitulos.contador].tiempoFin.milisegundos;
 			archivo.ignore();
 			getline(archivo, subtitulos.subtitulo[subtitulos.contador].subtitulo);
 			subtitulos.contador++;
 		}
 		cargado = true;
 	}
 	archivo.close();
 	return cargado;
 }
 int toMilisegundos(tTiempo& tiempo) {
 	int tiempoMS = 0, tiempoSec = 0, tiempoMin = 0;
 	tiempoMin = (tiempo.horas * 60) + tiempo.minutos;
 	tiempoSec = (tiempoMin * 60) + tiempo.segundos;
 	tiempoMS = (tiempoSec * 1000) + tiempo.milisegundos;
 	return tiempoMS;
 }
 int desajuste(const string& subtitulo, const int& intervalo) {
 	int desajuste = 0, tiempoSub = 0, diferencia = 0;
 	if (intervalo > 0) {
 	tiempoSub = subtitulo.length() * MAX_MILI;
 	diferencia = tiempoSub - intervalo;
 	desajuste = diferencia / MAX_MILI;
 	}
 	return desajuste;
 }
 void mostrar(tListaSub& subtitulos) {
 	cout << setw(40) << setfill('=') << "\n" << setfill(char(0));
 	for (int i = 0; i < subtitulos.contador; i++){
 		cout << "Intervalo: " << toMilisegundos(subtitulos.subtitulo[i].tiempoIni) << " --> " << toMilisegundos(subtitulos.subtitulo[i].tiempoFin) << endl
 			<< "Texto: " << subtitulos.subtitulo[i].subtitulo << endl << endl;
 	}
 	cout << setw(40) << setfill('=') << "\n" << setfill(char(0));
 }
 void cambiarTexto(tListaSub& subtitulos) {
 	int pos = 0;
 	cout << endl;
 	do {
 		cout << "Posicion en la lista: ";
 		cin >> pos;
 	} while (pos < 0 || pos >= subtitulos.contador);
 	cout << "Texto: ";
 	cin.ignore();
 	getline(cin, subtitulos.subtitulo[pos].subtitulo);
 }
 void buscar(tListaSub& subtitulos) {
 	int mili = 0, pos = 0, intervalo = 0;
 	cout << setw(40) << setfill('=') << "\n" << setfill(char(0));
 	cout << "Milisegundos: ";
 	cin >> mili;
 	if (buscarMili(subtitulos, mili, pos)) {
 		cout << "Encontrado en la posicion: " << pos << endl
 			<< "Intervalo: " << toMilisegundos(subtitulos.subtitulo[pos].tiempoIni) << " --> " << toMilisegundos(subtitulos.subtitulo[pos].tiempoFin) << endl
 			<< "Texto: " << subtitulos.subtitulo[pos].subtitulo << endl;
 		intervalo = toMilisegundos(subtitulos.subtitulo[pos].tiempoFin) - toMilisegundos(subtitulos.subtitulo[pos].tiempoIni);
 		cout << "Desajuste: " << desajuste(subtitulos.subtitulo[pos].subtitulo, intervalo) << endl;
 	}
 	else {
 		cout << "No encontrado." << endl;
 	}
 	cout << setw(40) << setfill('=') << "\n" << setfill(char(0));
 }
 bool buscarMili(tListaSub& subtitulos, const int& mili, int& i) {
 	bool encontrado = false;
 	while ((!encontrado) && (i < subtitulos.contador)) {
 		if ((mili > toMilisegundos(subtitulos.subtitulo[i].tiempoIni)) && (mili < toMilisegundos(subtitulos.subtitulo[i].tiempoFin))) {
 			encontrado = true;
 		}
 		else { 
 			i++; 
 		}
 	}
 	return encontrado;
 }
 bool guardar(tListaSub& subtitulos) {
 	bool save = false;
 	ofstream archivo;
 	archivo.open("subtitulosEX.txt");
 	if (!archivo.is_open()) {
 		save = false;
 	}
 	else {
 		for (int i = 0; i < subtitulos.contador; i++){
 			archivo << toMilisegundos(subtitulos.subtitulo[i].tiempoIni) << " "
 				<< toMilisegundos(subtitulos.subtitulo[i].tiempoFin) << " "
 				<< subtitulos.subtitulo[i].subtitulo << endl;
 		}
 		save = true;
 	}
 	archivo.close();
 	return save;
 }
 void ejecutarMenu(tListaSub& subtitulos) {
 	int opc = 1;
 	while (opc != 0) {
 		opc = menu();
 		switch (opc){
 		case 0: break;
 		case 1: mostrar(subtitulos); system("PAUSE"); break;
 		case 2: cambiarTexto(subtitulos); system("PAUSE"); break;
 		case 3: buscar(subtitulos); system("PAUSE"); break;
 		default:
 			break;
 		}
 		system("cls");
 	}
 }
 int menu() {
 	int opc = 0;
 	cout << setw(20) << setfill('=') << "MENU" << setw(20) << "\n" << setfill(char(0));
 	cout << "1.-Mostrar lista." << endl;
 	cout << "2.-Cambiar texto." << endl;
 	cout << "3.-Buscar subtitulo." << endl;
 	cout << "0.-Salir." << endl;
 	cout << setw(40) << setfill('=') << "\n" << setfill(char(0));
 	do {
 		cout << "Introduzca una opcion: ";
 		cin >> opc;
 	} while (opc < 0 || opc > 3);
 	return opc;
 }
--- a/I)/Febrero2019DEI.pdf
+++ b/I)/Febrero2019DEI.pdf
--- a/I)/subtitulos.txt
+++ b/I)/subtitulos.txt
@ -0,0 +1,5 @@
 00:00:00,394 00:00:03,031 Anteriormente en Sons of Anarchy...
 00:00:03,510 00:00:04,260 Ponte esto. Ayudará.
 00:10:13,990 00:10:14,703 Texto del subtítulo 4.
 00:20:19,008 00:25:19,100 Se vengó de la persona equivocada. Y ahora tiene a mi hijo.
 01:00:59,998 01:01:00,123 Texto del subtítulo 11.
		`@ -0,0 +1,93 @@`
							`12345`
							`1`
							`2`
							`3`
							`4`
							`5`
							`2134`
							`65`
							`789`
							`44`
							`432`
							`123`
							`3`
							`561`
							`32`
							`24567`
							`46`
							`53767`
							`7655`
							`12347`
							`98765`
							`9`
							`788`
							`654`
							`12`
							`134`
							`5658`
							`542`
							`456`
							`876`
							`3`
							`56`
							`32333`
							`3233`
							`323`
							`32`
							`3`
							`12345`
							`1234`
							`123`
							`12`
							`1`
							`12`
							`123`
							`1234`
							`12345`
							`9`
							`98`
							`987`
							`9876`
							`98765`
							`9876`
							`987`
							`98`
							`9`
							`5567`
							`54664`
							`5`
							`75`
							`342`
							`19`
							`22`
							`23`
							`20`
							`75`
							`57`
							`10000`
							`1000`
							`100`
							`10`
							`1`
							`0`
							`96`
							`99`
							`1996`
							`1999`
							`98`
							`35`
							`9`
							`8`
							`3`
							`5`
							`7654`
							`743`
							`5`
							`32526`
							`2`
							`5`
							`5676`
							`23`
							`687`
							`54367`
							`9`
+EquipoA
+9 8 0
+EquipoB
+4 1 0
+EquipoC
+5 4 0
+EquipoD
+3 2 1
+EquipoE
+2 1 0
+EquipoF
+5 3 1
+EquipoG
+6 1 1
+EquipoH
+5 2 1
+EquipoI
+4 1 0
+EquipoJ
+3 0 1
+XXX