Add files via upload

Exámenes Resueltos (Segundo Semestre)/June2017I/ClientList.h

@@ -0,0 +1,31 @@
+#ifndef _CLIENTLIST
+#define _CLIENTLIST
+
+#include <iostream>
+#include <string>
+#include <fstream>
+#include <iomanip>
+
+//Constant:
+const int MAX_CLIENTS = 50;
+
+
+//Types:
+typedef struct tClient {
+	std::string login, registerDate, city;
+	int age;
+};
+
+typedef struct tClientList {
+	tClient *client[MAX_CLIENTS];
+	int cont;
+};
+
+//Functions:
+void display(tClient& client);
+bool load(tClientList& list);
+void show(tClientList list, int&); //Implement using recursion.
+void free(tClientList& list);
+
+
+#endif // !_CLIENTLIST

Exámenes Resueltos (Segundo Semestre)/June2017I/ClientListcpp.cpp

@@ -0,0 +1,53 @@
+#include "ClientList.h"
+using namespace std;
+
+void display(tClient& client) {
+	cout << right << setw(10) << client.login
+		<< setw(15) << client.registerDate
+		<< setw(5) << client.age << " years"
+		<< setw(10) << client.city << endl;
+}
+
+bool load(tClientList& list) {
+	bool loaded = false;
+	ifstream file;
+	int numClients = 0;
+
+	list.cont = 0;
+
+	file.open("clients.txt");
+	if (!file.is_open()) {
+		cout << "Failed to load clients." << endl;
+	}
+	else {
+		file >> numClients;
+		while (!file.fail() && list.cont < numClients) {
+			list.client[list.cont] = new tClient;
+			file >> list.client[list.cont]->login;
+			file >> list.client[list.cont]->registerDate;
+			file >> list.client[list.cont]->age;
+			file >> list.client[list.cont]->city;
+			list.cont++;
+		}
+		loaded = true;
+	}
+	file.close();
+
+	return loaded;
+}
+
+void show(tClientList list, int& i) {
+
+	if (i < list.cont) {
+		cout << i + 1 << ":";
+		display(*list.client[i]);
+		i++;
+		show(list, i);
+	}
+}
+
+void free(tClientList& list) {
+	for (int i = 0; i < list.cont; i++){
+		delete list.client[i];
+	}
+}

Exámenes Resueltos (Segundo Semestre)/June2017I/DateList.cpp

@@ -0,0 +1,48 @@
+#include "DateList.h"
+using namespace std;
+
+//Auxiliary functions:
+void expand(tDateList& list, int& newCapacity);
+
+void newList(tDateList& list) {
+	list.capacity = 10;
+	list.cont = 0;
+	list.date = new tDate[list.capacity];
+}
+
+void insert(tDateList& list, tDate& date) {
+	if (list.cont == list.capacity) {
+		expand(list, list.capacity);
+	}
+	list.date[list.cont] = date;
+	list.cont++;
+}
+
+//
+void expand(tDateList& list, int& newCapacity) {
+	list.capacity += newCapacity;
+	tDate *aux = new tDate[list.capacity];
+
+	for (int i = 0; i < list.cont; i++){
+		aux[i] = list.date[i];
+	}
+
+	delete[] list.date;
+	list.date = aux;
+
+}
+//
+
+void display(tDateList& list) {
+	cout << setfill(char('-')) << setw(50) << "\n" << setfill(char(0));
+	for (int i = 0; i < list.cont; i++){
+		display(*list.date[i].client1);
+		display(*list.date[i].client2);
+		cout << "Date in: " <<  list.date[i].place << ". Rating: " << list.date[i].ratting << endl;
+		cout << setfill(char('-')) << setw(50) << "\n" << setfill(char(0));
+	}
+}
+
+void free(tDateList& list) {
+	delete[] list.date;
+}

Exámenes Resueltos (Segundo Semestre)/June2017I/DateList.h

@@ -0,0 +1,30 @@
+#ifndef _DATELIST
+#define _DATELIST
+
+#include "ClientList.h"
+
+//Constant:
+
+
+
+//Types:
+typedef struct tDate {
+	tClient *client1, *client2;
+	std::string place;
+	int ratting;
+};
+
+typedef struct tDateList {
+	tDate *date; //Sorted by rating.
+	int cont, capacity;
+};
+
+
+//Functions:
+void newList(tDateList& list);
+void insert(tDateList& list, tDate& date); //If there are no more free slots add 10 more slots.
+void display(tDateList& list);
+void free(tDateList& list);
+
+
+#endif // !_DATELIST

Exámenes Resueltos (Segundo Semestre)/June2017I/checkML.h

@@ -0,0 +1,9 @@
+#ifdef _DEBUG
+#define _CRTDBG_MAP_ALLOC
+#include <stdlib.h>
+#include <crtdbg.h>
+#ifndef DBG_NEW
+#define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )
+#define new DBG_NEW
+#endif
+#endif

Exámenes Resueltos (Segundo Semestre)/June2017I/clients.txt

@@ -0,0 +1,21 @@
+5
+Luis
+15/06/08
+27
+Madrid
+Ana
+23/03/02
+18
+Avila
+Maria
+02/05/14
+25
+Burgos
+Fernando
+25/09/2015
+19
+Madrid
+Lena
+21/09/2017
+18
+Madrid

Exámenes Resueltos (Segundo Semestre)/June2017I/main.cpp

@@ -0,0 +1,80 @@
+//Exam June 2017 - FP
+//Groups: I
+//Fernando Méndez Torrubiano
+
+#include "DateList.h"
+#include "checkML.h"
+using namespace std;
+
+//Auxiliary functions:
+int menu();
+
+int main() {
+	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); //Shows memory leaks.
+
+	tClientList clients;
+	tDateList dates;
+	tDate date;
+	int c1, c2;
+	int opc = -1, i = 0;
+
+	if (load(clients)) {
+		newList(dates);
+		while (opc != 0) {
+			opc = menu();
+			switch (opc){
+			case 1: 
+				show(clients, i); 
+				break;
+			case 2: 
+				show(clients, i);
+				cout << "Clients: ";
+				cin >> c1;
+				cin >> c2;
+				date.client1 = clients.client[c1 - 1];
+				date.client2 = clients.client[c2 - 1];
+				cout << "Date´s place: ";
+				cin >> date.place;
+				do {
+					cout << "Date´s rating [0-5]: ";
+					cin >> date.ratting;
+				} while (date.ratting < 0 || date.ratting > 5);
+				insert(dates, date);
+				break;
+			case 3: 
+				cout << "Date list: " << endl; 
+				display(dates);
+				break;
+			default:
+				break;
+			}
+			i = 0;
+		}
+	}
+	else {
+		cout << "End of program." << endl;
+	}
+
+	free(clients);
+	free(dates);
+
+	return 0;
+}
+
+int menu() {
+	int opc = 0;
+	
+	cout << setfill(char('-')) << setw(50) << "\n" << setfill(char(0));
+	cout << "1.-Display client list." << endl;
+	cout << "2.-New date." << endl;
+	cout << "3.-Display dates." << endl;
+	cout << "0.-EXIT." << endl;
+	cout << setfill(char('-')) << setw(50) << "\n" << setfill(char(0));
+
+	do {
+		cout << "Choose an option: ";
+		cin >> opc;
+	} while (opc < 0 || opc > 3);
+
+	return opc;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2016D/CheckML.h

@@ -0,0 +1,12 @@
+#ifdef _DEBUG  
+#define _CRTDBG_MAP_ALLOC  
+
+#include <stdlib.h>  
+#include <crtdbg.h>  
+
+#ifndef DBG_NEW  
+#define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )  
+#define new DBG_NEW 
+
+#endif  
+#endif

Exámenes Resueltos (Segundo Semestre)/Junio2016D/ListaPeliculas.cpp

@@ -0,0 +1,82 @@
+#include "ListaPeliculas.h"
+using namespace std;
+
+
+bool cargar(tListaPeliculas & listaPelis){
+	bool carga = false;
+	ifstream archivo;
+	int numPelis = 0;
+
+	listaPelis.cont = 0;
+	archivo.open("peliculas.txt");
+	if (archivo.is_open()) {
+		archivo >> numPelis;
+		archivo.ignore();
+		while ((!archivo.fail()) && (listaPelis.cont < numPelis)){
+			listaPelis.pelicula[listaPelis.cont] = new tPelicula;
+			carga = cargar(*listaPelis.pelicula[listaPelis.cont], archivo);
+			listaPelis.cont++;
+		}
+	}
+
+	return carga;
+}
+
+void filtrarPorActor(tListaPeliculas & listaPelis, std::string & nombre){
+	tListaPeliculas listaAUX;
+	listaAUX.cont = 0;
+
+	for (int i = 0; i < listaPelis.cont; i++) {
+		if (interviene(*listaPelis.pelicula[i], nombre)) {
+			listaAUX.pelicula[listaAUX.cont] = listaPelis.pelicula[i];
+			listaAUX.cont++;
+		}
+	}
+
+	ordenarPorGenero(listaAUX);
+	mostrar(listaAUX);
+	
+}
+
+void mostrar(tListaPeliculas& listaPelis){
+	for (int i = 0; i < listaPelis.cont; i++){
+		mostrar(*listaPelis.pelicula[i]);
+		cout << "---" << endl;
+	}
+}
+
+void ordenarPorGenero(tListaPeliculas& listaPelis){
+	tPelicula* AUX;
+	int cont;
+
+	for (int i = 0; i < listaPelis.cont; i++) {
+		cont = i;
+		while ((cont > 0) && (listaPelis.pelicula[cont]->genero <= listaPelis.pelicula[cont - 1]->genero)) { //
+			if (listaPelis.pelicula[cont]->genero == listaPelis.pelicula[cont - 1]->genero) {
+				ordenarPorValoracion(*listaPelis.pelicula[cont - 1], *listaPelis.pelicula[cont]);
+			}
+			else {
+				AUX = listaPelis.pelicula[cont];
+				listaPelis.pelicula[cont] = listaPelis.pelicula[cont - 1];
+				listaPelis.pelicula[cont - 1] = AUX;
+			}
+			cont--;
+		}
+	}
+}
+
+void ordenarPorValoracion(tPelicula& pelIZQ, tPelicula& pelDER){
+	tPelicula AUX;
+
+	if (pelIZQ.valoracion < pelDER.valoracion) {
+		AUX = pelIZQ;
+		pelIZQ = pelDER;
+		pelDER = AUX;
+	}
+}
+
+void destruir(tListaPeliculas & listaPelis){
+	for (int i = 0; i < listaPelis.cont; i++){
+		delete listaPelis.pelicula[i];
+	}
+}

Exámenes Resueltos (Segundo Semestre)/Junio2016D/ListaPeliculas.h

@@ -0,0 +1,24 @@
+#ifndef H_LISTAPELICULAS_H
+#define H_LISTAPELICULAS_H
+
+#include "Pelicula.h"
+
+//Constantes:
+const int MAX_PELIS = 50;
+
+//Tipos:
+typedef struct tListaPeliculas {
+	tPelicula *pelicula[MAX_PELIS];
+	int cont;
+};
+
+//Funciones:
+bool cargar(tListaPeliculas& listaPelis); //Carga la lista de películas.
+void filtrarPorActor(tListaPeliculas& listaPelis, std::string& nombre); //Genera nueva lista que contiene enlaces a las películas donde ha participado ese actor.
+void mostrar(tListaPeliculas& listaPelis); //Muestra la lista de películas
+void ordenarPorGenero(tListaPeliculas& listaPelis); //Ordenadas por género de menor a mayor.
+void ordenarPorValoracion(tPelicula& pelIZQ, tPelicula& pelDER); //Ordenación por inserción. Ordenadas por valoración de mayor a menor.
+void destruir(tListaPeliculas& listaPelis);
+
+#endif // !H_LISTAPELICULAS_H
+

Exámenes Resueltos (Segundo Semestre)/Junio2016D/Pelicula.cpp

@@ -0,0 +1,42 @@
+#include "Pelicula.h"
+using namespace std;
+
+bool cargar(tPelicula& pelicula, ifstream& archivo){
+	bool cargado = false;
+	pelicula.contReparto = 0;
+
+	getline(archivo, pelicula.titulo);
+	getline(archivo, pelicula.director);
+	getline(archivo, pelicula.genero);
+	getline(archivo, pelicula.valoracion);
+	archivo >> pelicula.contReparto;
+	archivo.ignore();
+	for (int i = 0; i < pelicula.contReparto; i++){
+		cargado = cargar(pelicula.listaReparto[i], archivo);
+	}
+
+	return cargado;
+}
+
+bool interviene(tPelicula& pelicula, std::string& nombre){
+	bool encontrado = false;
+	int j = 0;
+
+	while(!encontrado && j < pelicula.contReparto){
+		if (pelicula.listaReparto[j].nombre == nombre) {
+			encontrado = true;
+		}
+		else {
+			j++;
+		}
+	}
+
+	return encontrado;
+}
+
+void mostrar(tPelicula& pelicula){
+	cout << "Titulo:" << setw(5) << pelicula.titulo << endl
+		<< "Director: " << setw(5) << pelicula.director << endl
+		<< "Género:" << setw(5) << pelicula.genero << endl
+		<< "Valoracion:" << setw(5) << pelicula.valoracion << endl;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2016D/Pelicula.h

@@ -0,0 +1,21 @@
+#ifndef H_PELICULA_H
+#define H_PELICULA_H
+
+#include "Reparto.h"
+
+//Constantes:
+
+
+//Tipos:
+typedef struct tPelicula {
+	std::string titulo, director, genero, valoracion;
+	tReparto listaReparto[MAX_ACTORES];
+	int contReparto;
+};
+
+//Funciones:
+bool cargar(tPelicula& pelicula, std::ifstream&); //Carga una película.
+bool interviene(tPelicula& pelicula, std::string& nombre); //True si el actor se encuentra en la película, false en caso contrario.
+void mostrar(tPelicula& pelicula); //Muestra por pantalla el título, director, género y valoración de una película.
+
+#endif // !H_PELICULA_H

Exámenes Resueltos (Segundo Semestre)/Junio2016D/Reparto.cpp

@@ -0,0 +1,19 @@
+#include "Reparto.h"
+using namespace std;
+
+bool cargar(tReparto& reparto, ifstream& archivo){
+	bool carga = false;
+
+	if (!archivo.fail()) {
+		getline(archivo, reparto.nombre);
+		carga = true;
+	}
+
+	return carga;
+}
+
+bool aparece(tReparto& reparto, string & nombre, int & pos){
+	bool encontrado = false;
+
+	return encontrado;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2016D/Reparto.h

@@ -0,0 +1,24 @@
+#ifndef H_REPARTO_H
+#define H_REPARTO_H
+
+#include <iostream>
+#include <string>
+#include <fstream>
+#include <iomanip>
+
+//Constantes:
+const int MAX_ACTORES = 10;
+
+//Tipos:
+typedef struct tReparto {
+	std::string nombre;
+};
+
+//typedef tReparto tListaReparto[MAX_ACTORES];
+
+//Funciones:
+bool cargar(tReparto& reparto, std::ifstream&); //Carga la lista del reparto.
+bool aparece(tReparto reparto, std::string& nombre, int& pos); //True si encuentra el nombre en la lista, false en caso contrario. Implementar de forma recursiva.
+
+#endif // !H_REPARTO_H
+

Exámenes Resueltos (Segundo Semestre)/Junio2016D/main.cpp

@@ -0,0 +1,38 @@
+//Examen Junio de 2016 - FP
+//Grupo D
+//Fernando Méndez Torrubiano
+
+#include <iostream>
+#include <string>
+#include <fstream>
+#include <iomanip>
+#include <stdlib.h>
+#include "ListaPeliculas.h"
+#include "CheckML.h"
+using namespace std;
+
+
+int main() {
+	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); //Detecta posibles fugas de memoria.
+	system("chcp 1252"); //Así la consola puede imprimir caracteres especiales del español.
+	system("cls");
+
+
+	tListaPeliculas lista;
+	string nombre;
+
+	if (cargar(lista)) {
+		cout << "Introduzca nombre del actor: ";
+		getline(cin, nombre);
+		//mostrar(lista);
+		filtrarPorActor(lista, nombre);
+	}
+	else {
+		cout << "No se ha podido cargar el archivo." << endl;
+	}
+
+	destruir(lista); //Libera la memoria dinámica.
+
+	system("PAUSE");
+	return 0;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2016D/peliculas.txt

@@ -0,0 +1,38 @@
+4
+X-MEN: Apocalipsis
+Bryan Singer
+Ciencia ficción
+6.3
+5
+James McAvoy
+Michael Fassbender
+Jennifer Lawrence
+Nicholas Hoult
+Oscar Issac
+La invención de Hugo
+Martin Scorsese
+Aventuras
+6.8
+4
+Asa Butterfield
+Ben Kingsley
+Sacha Baron Cohen
+Jude Law
+Noche en el museo: El secreto del faraón
+Shawn Levy
+Comedia
+5.1
+5
+Robin Williams
+Ben Kingsley
+San Stevens
+Ben Stiller
+Ricky Gervais
+El libro de la selva
+Jon Favreau
+Aventuras
+7.0
+3
+Neel Sethi
+Bill Murray
+Ben Kingsley

Exámenes Resueltos (Segundo Semestre)/Junio2016_1/ListaReproduccion.cpp

@@ -0,0 +1,72 @@
+#include "ListaReproduccion.h"
+using namespace std;
+
+void nueva(tListaReproduccion& lista) {
+	//La capacidad y el nombre se guardan directamente en el main().
+
+	lista.elemento = new tElemento[lista.capacidad];
+	lista.cont = 0;
+}
+
+bool insertar(tListaReproduccion& lista, tElemento& elemento) {
+	bool insertado = false;
+	int ini = 0, fin = lista.cont - 1, pos = 0;
+
+	if (!buscar(lista, elemento.puntero[pos].titulo, ini, fin, pos)) {
+		lista.elemento[lista.cont].puntero = elemento.puntero;
+		lista.elemento[lista.cont].valoracion = elemento.valoracion;
+		lista.cont++;
+		insertado = true;
+	}
+	else {
+		lista.elemento[pos].puntero = elemento.puntero;
+		lista.elemento[pos].valoracion = elemento.valoracion;
+	}
+
+	return insertado;
+}
+
+bool buscar(tListaReproduccion& lista, std::string titulo, int& ini, int& fin, int& pos) {
+	bool encontrado = false;
+	
+	if (ini <= fin) {
+		pos = (ini + fin) / 2;
+		if (titulo < lista.elemento[pos].puntero->titulo) {
+			fin = pos - 1;
+			encontrado = buscar(lista, titulo, ini, fin, pos);
+		}
+		else if (lista.elemento[pos].puntero->titulo < titulo) {
+			ini = pos + 1;
+			encontrado = buscar(lista, titulo, ini, fin, pos);
+		}
+		else {
+			encontrado = true;
+		}
+	}
+
+	return encontrado;
+}
+
+void mostrar(tListaReproduccion& lista) {
+	cout << "Lista: " << lista.nombreLista << endl;
+	for (int i = 0; i < lista.cont; i++){
+		cout << i + 1 << ".-";
+		mostrar(*lista.elemento[i].puntero);
+		cout << " (" << lista.elemento[i].valoracion << ")" << endl;
+	}
+}
+
+void modificarOrden(tListaReproduccion& lista, int& origen, int& fin) {
+	tElemento aux;
+	aux = lista.elemento[origen];
+
+	for (int i = origen; i > fin - 1; i--){
+		lista.elemento[i] = lista.elemento[i - 1];
+	}
+
+	lista.elemento[fin] = aux;
+}
+
+void destruir(tListaReproduccion& lista) {
+	delete[] lista.elemento;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2016_1/ListaReproduccion.h

@@ -0,0 +1,31 @@
+#ifndef _LISTAREPRODUCCIONES
+#define _LISTAREPRODUCCIONES
+
+#include "ListaTemas.h"
+
+//Constantes:
+
+
+//Tipos:
+typedef struct tElemento {
+	tTema *puntero;
+	int valoracion;
+};
+
+typedef struct tListaReproduccion{
+	tElemento *elemento;
+	std::string nombreLista;
+	int capacidad;
+	int cont;
+};
+
+//Funciones:
+void nueva(tListaReproduccion& lista);
+bool insertar(tListaReproduccion& lista, tElemento& elemento);
+bool buscar(tListaReproduccion& lista, std::string titulo, int& ini, int& fin, int& pos); //Binaria y recursiva.
+void mostrar(tListaReproduccion& lista);
+void modificarOrden(tListaReproduccion& lista, int& origen, int& fin);
+void destruir(tListaReproduccion& lista);
+
+
+#endif // !_LISTAREPRODUCCIONES

Exámenes Resueltos (Segundo Semestre)/Junio2016_1/ListaTemas.cpp

@@ -0,0 +1,34 @@
+#include "ListaTemas.h"
+using namespace std;
+
+bool cargar(tListaTemas& lista) {
+	bool carga = false;
+	ifstream archivo;
+	int numTemas = 0;
+
+	lista.cont = 0;
+
+	archivo.open("temas.txt");
+	if (!archivo.is_open()) {
+		cout << "Error al cargar los temas." << endl;
+	}
+	else {
+		archivo >> numTemas;
+		while (!archivo.fail() && lista.cont < numTemas) {
+			lista.tema[lista.cont] = new tTema;
+			if (cargar(*lista.tema[lista.cont], archivo)) {
+				lista.cont++;
+			}
+		}
+		carga = true;
+	}
+	archivo.close();
+
+	return carga;
+}
+
+void destruir(tListaTemas& lista) {
+	for (int i = 0; i < lista.cont; i++){
+		delete lista.tema[i];
+	}
+}

Exámenes Resueltos (Segundo Semestre)/Junio2016_1/ListaTemas.h

@@ -0,0 +1,20 @@
+#ifndef _LISTATEMAS
+#define _LISTATEMAS
+
+#include "Tema.h"
+
+//Constantes:
+const int MAX_TEMAS = 50;
+
+//Tipos:
+typedef struct tListaTemas {
+	tTema *tema[MAX_TEMAS];
+	int cont;	
+};
+
+//Funciones:
+bool cargar(tListaTemas& lista);
+void destruir(tListaTemas& lista);
+
+
+#endif // !_LISTATEMAS

Exámenes Resueltos (Segundo Semestre)/Junio2016_1/Tema.cpp

@@ -0,0 +1,21 @@
+#include "Tema.h"
+using namespace std;
+
+bool cargar(tTema& tema, ifstream& archivo) {
+	bool carga = false;
+
+	if (!archivo.fail()) {
+		archivo >> tema.titulo;
+		archivo >> tema.interprete;
+		archivo >> tema.segundos;
+		carga = true;
+	}
+
+	return carga;
+}
+
+void mostrar(tTema& tema) {
+	cout << right << setw(7) << tema.titulo
+		<< setw(15) << tema.interprete
+		<< setw(10) << tema.segundos << " seg.";
+}

Exámenes Resueltos (Segundo Semestre)/Junio2016_1/Tema.h

@@ -0,0 +1,23 @@
+#ifndef _TEMA
+#define _TEMA
+
+#include <iostream>
+#include <string>
+#include <fstream>
+#include <iomanip>
+
+//Constantes:
+
+
+//Tipos:
+typedef struct tTema {
+	std::string titulo, interprete;
+	int segundos;
+};
+
+//Funciones:
+bool cargar(tTema& tema, std::ifstream&);
+void mostrar(tTema& tema);
+
+
+#endif // !_TEMA

Exámenes Resueltos (Segundo Semestre)/Junio2016_1/checkML.h

@@ -0,0 +1,9 @@
+#ifdef _DEBUG
+#define _CRTDBG_MAP_ALLOC
+#include <stdlib.h>
+#include <crtdbg.h>
+#ifndef DBG_NEW
+#define DBG_NEW new (_NORMAL_BLOCK , __FILE__ , __LINE__ )
+#define new DBG_NEW
+#endif
+#endif // _DEBUG

Exámenes Resueltos (Segundo Semestre)/Junio2016_1/main.cpp

@@ -0,0 +1,56 @@
+//Examen Junio 2016 - FP
+//Grupo_1
+//Fernando Méndez Torrubiano
+
+#include "ListaReproduccion.h"
+#include "checkML.h"
+using namespace std;
+
+int main() {
+	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); //Detecta fugas de memoria.
+	system("chcp 1252"); //Castellano.
+	system("cls");
+	srand(1);
+
+	tListaTemas listaTemas;
+	tListaReproduccion listaReproduccion;
+	int origen, fin;
+	
+	if (cargar(listaTemas)) {
+		cout << "Nombre: ";
+		cin >> listaReproduccion.nombreLista;
+		do {
+			cout << "Numero de temas: ";
+			cin >> listaReproduccion.capacidad;
+		} while (listaReproduccion.capacidad < 0 || listaReproduccion.capacidad > listaTemas.cont);
+
+		nueva(listaReproduccion);
+		for (int i = 0; i < listaReproduccion.capacidad; i++){
+			listaReproduccion.elemento[i].puntero = listaTemas.tema[0 + rand() % listaReproduccion.capacidad];
+			listaReproduccion.elemento[i].valoracion = 0 + rand() % listaReproduccion.capacidad;
+			if (!insertar(listaReproduccion, listaReproduccion.elemento[i])) {
+				i--;
+			}
+		}
+		mostrar(listaReproduccion);
+
+		origen = 4;
+		//origen = 0 + rand() % listaReproduccion.capacidad;
+		fin = 0;
+		//fin = 0 + rand() % listaReproduccion.capacidad;
+		cout << "Cambio de orden: " << origen + 1 << " al " << fin + 1 << endl;
+		modificarOrden(listaReproduccion, origen, fin);
+		mostrar(listaReproduccion);
+
+		system("PAUSE");
+	}
+	else {
+		cout << "Fin del programa." << endl;
+		system("PAUSE");
+	}
+
+	destruir(listaTemas);
+	destruir(listaReproduccion);
+
+	return 0;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2016_1/temas.txt

@@ -0,0 +1,16 @@
+5
+titulo1
+interprete1
+240
+titulo2
+interprete2
+274
+titulo3
+interprete3
+180
+titulo4
+interprete4
+60
+titulo5
+interprete5
+60

Exámenes Resueltos (Segundo Semestre)/Junio2016_2/Estudiante.cpp

@@ -0,0 +1,27 @@
+#include "Estudiante.h"
+using namespace std;
+
+bool cargar(tEstudiante& estudiante, std::ifstream& archivo) {
+	bool cargar = false;
+
+	if (!archivo.fail()) {
+		archivo.ignore();
+		getline(archivo, estudiante.nombre);
+		archivo >> estudiante.NIF;
+		archivo >> estudiante.fechaMatricula;
+		archivo >> estudiante.nota;
+		cargar = true;
+	}
+
+	return cargar;
+}
+
+void mostrar(tEstudiante& estudiante) {
+	cout << right << setw(9) << estudiante.NIF
+		<< setw(2) << "-" << setw(2)
+		<< setw(8) << estudiante.fechaMatricula
+		<< setw(2) << "-" << setw(2)
+		<< setw(3) << estudiante.nota
+		<< setw(2) << "-" << setw(2)
+		<< setw(20) << estudiante.nombre << endl;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2016_2/Estudiante.h

@@ -0,0 +1,23 @@
+#ifndef _ESTUDIANTE
+#define _ESTUDIANTE
+
+#include <iostream>
+#include <string>
+#include <fstream>
+#include <iomanip>
+
+//Constantes:
+
+
+//Tipos:
+typedef struct tEstudiante {
+	std::string nombre, NIF, fechaMatricula;
+	int nota;
+};
+
+//Funciones:
+bool cargar(tEstudiante& estudiante, std::ifstream& archivo);
+void mostrar(tEstudiante& estudiante);
+
+
+#endif // !_ESTUDIANTE

Exámenes Resueltos (Segundo Semestre)/Junio2016_2/ListaEstudiantes.cpp

@@ -0,0 +1,63 @@
+#include "ListaEstudiantes.h"
+using namespace std;
+
+bool cargar(tListaEstudiantes& lista, ifstream& archivo, int& numAlumnos) {
+	bool carga = false;
+	lista.estudiante = new tEstudiante[numAlumnos];
+	lista.cont = 0;
+
+	if (insertar(lista, numAlumnos, archivo)) {
+		carga = true;
+	}
+
+	return carga;
+}
+
+bool buscar(tListaEstudiantes& lista, std::string NIF, int& ini, int& fin, int& pos) {
+	bool encontrado = false;
+
+	if (ini <= fin) {
+		pos = (ini + fin) / 2;
+		if (NIF < lista.estudiante[pos].NIF) {
+			fin = pos - 1;
+			encontrado = buscar(lista, NIF, ini, fin, pos);
+		}
+		else if (lista.estudiante[pos].NIF < NIF) {
+			ini = pos + 1;
+			encontrado = buscar(lista, NIF, ini, fin, pos);
+		}
+		else {
+			encontrado = true;
+		}
+	}
+
+	return encontrado;
+}
+
+bool insertar(tListaEstudiantes& estudiante, int& numAlumnos, ifstream& archivo) {
+	bool insertado = false;
+	int ini = 0, fin = estudiante.cont - 1, pos = 0;
+
+	for (int i = 0; i < numAlumnos; i++) {
+		if (!buscar(estudiante, estudiante.estudiante[estudiante.cont].NIF, ini, fin, pos)) {
+			for (int i = estudiante.cont; i > 0; i--){
+				estudiante.estudiante[i] = estudiante.estudiante[i - 1];
+			}
+			if (cargar(estudiante.estudiante[pos], archivo)) {
+				estudiante.cont++;
+				insertado = true;
+			}
+		}
+	}
+	return insertado;
+}
+
+void mostrar(tListaEstudiantes& estudiante) {
+	for (int i = 0; i < estudiante.cont; i++){
+		mostrar(estudiante.estudiante[i]);
+	}
+}
+
+void destruir(tListaEstudiantes& estudiantes) {
+	delete[] estudiantes.estudiante;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2016_2/ListaEstudiantes.h

@@ -0,0 +1,24 @@
+#ifndef _LISTAESTUDIANTES
+#define _LISTAESTUDIANTES
+
+#include "Estudiante.h"
+
+//Constantes:
+
+
+//Tipos:
+typedef struct tListaEstudiantes {
+	tEstudiante *estudiante;	//Ordenada por NIF.
+	int cont;
+};
+
+
+//Funciones:
+bool cargar(tListaEstudiantes& lista, std::ifstream& archivo, int&);
+bool buscar(tListaEstudiantes& lista, std::string NIF, int& ini, int& fin, int& pos); //Binaria y recursiva.
+bool insertar(tListaEstudiantes& estudiante, int&, std::ifstream&);
+void mostrar(tListaEstudiantes& estudiante);
+void destruir(tListaEstudiantes& estudiantes);
+
+
+#endif // !_LISTAESTUDIANTES

Exámenes Resueltos (Segundo Semestre)/Junio2016_2/ListaGrupos.cpp

@@ -0,0 +1,62 @@
+#include "ListaGrupos.h"
+using namespace std;
+
+bool cargar(tListaGrupos& grupos) {
+	bool carga = false;
+	ifstream archivo;
+	int numAlum = 0;
+
+	grupos.cont = 0;
+
+	archivo.open("notas.txt");
+	if (!archivo.is_open()) {
+		cout << "No se ha podido cargar las notas." << endl;
+	}
+	else {
+		while (!archivo.fail()) {
+			grupos.grupo[grupos.cont] = new tGrupo;
+			archivo >> grupos.grupo[grupos.cont]->id;
+			archivo >> numAlum;
+			if (cargar(grupos.grupo[grupos.cont]->estudiantes, archivo, numAlum)) {
+				grupos.cont++;
+				carga = true;
+			}
+		}
+	}
+	archivo.close();
+
+	return carga;
+}
+
+void mostrar(tListaGrupos& grupos) {
+	cout << setfill(char('-')) << setw(50) << "\n" << setfill(char(0));
+	for (int i = 0; i < grupos.cont; i++){
+		cout << "GRUPO: " << grupos.grupo[i]->id << endl;
+		mostrar(grupos.grupo[i]->estudiantes);
+		cout << setfill(char('-')) << setw(50) << "\n" << setfill(char(0));
+	}
+}
+
+bool buscar(tListaGrupos& grupos, std::string NIF, int& i) {
+	bool encontrado = false, busqueda = false;
+	int ini = 0, fin = grupos.grupo[i]->estudiantes.cont - 1, pos = 0;
+	
+	if (!busqueda && i < grupos.cont) {
+		encontrado = buscar(grupos.grupo[i]->estudiantes, NIF, ini, fin, pos);
+		if (encontrado) {
+			busqueda = true;
+		}
+		else {
+			i++;
+			busqueda = buscar(grupos, NIF, i);
+		}
+	}
+	return busqueda;
+}
+
+void destruir(tListaGrupos grupos) {
+	for (int i = 0; i <= grupos.cont; i++){
+		destruir(grupos.grupo[i]->estudiantes);
+		delete grupos.grupo[i];
+	}
+}

Exámenes Resueltos (Segundo Semestre)/Junio2016_2/ListaGrupos.h

@@ -0,0 +1,27 @@
+#ifndef _LISTAGRUPOS
+#define _LISTAGRUPOS
+
+#include "ListaEstudiantes.h"
+
+//Constantes:
+const int MAX_GRUPOS = 10;
+
+//Tipos:
+typedef struct tGrupo {
+	tListaEstudiantes estudiantes;
+	std::string id;
+};
+
+typedef struct tListaGrupos {
+	tGrupo *grupo[MAX_GRUPOS];
+	int cont;
+};
+
+
+//Funciones:
+bool cargar(tListaGrupos& grupos);
+void mostrar(tListaGrupos& grupos);
+bool buscar(tListaGrupos& grupos, std::string NIF, int& pos); //Recursiva;
+void destruir(tListaGrupos grupos);
+
+#endif // !_LISTAGRUPOS

Exámenes Resueltos (Segundo Semestre)/Junio2016_2/checkML.h

@@ -0,0 +1,9 @@
+#ifdef _DEBUG
+#define _CRTDBG_MAP_ALLOC
+#include <stdlib.h>
+#include <crtdbg.h>
+#ifndef DBG_NEW
+#define DBG_NEW new (_NORMAL_BLOCK , __FILE__ , __LINE__ )
+#define new DBG_NEW
+#endif
+#endif // _DEBUG

Exámenes Resueltos (Segundo Semestre)/Junio2016_2/main.cpp

@@ -0,0 +1,36 @@
+//Examen Junio 2016 - FP
+//Grupo_2
+//Fernando Méndez Torrubiano
+
+#include "ListaGrupos.h"
+#include "checkML.h"
+using namespace std;
+
+int main() {
+	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); //Detecta fugas de memoria.
+	system("chcp 1252");//Castellano.
+	system("cls");
+
+	tListaGrupos grupos;
+	string NIF;
+	int pos = 0;
+
+	if (cargar(grupos)) {
+		mostrar(grupos);
+		cout << endl << "Introduce un NIF: ";
+		cin >> NIF;
+		if (buscar(grupos, NIF, pos)) {
+			cout << "Grupo: " << grupos.grupo[pos]->id << endl;
+		}
+		else {
+			cout << "No se ha encontrado el alumno." << endl;
+		}
+	}
+	else {
+		cout << "FIN DEL PROGRAMA." << endl;
+	}
+	system("PAUSE");
+	destruir(grupos);
+
+	return 0;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2016_2/notas.txt

@@ -0,0 +1,14 @@
+A
+3
+nombre1 apellidos1
+76541321G 15/06/01 10
+nombre2 apellidos2
+92648282F 15/06/06 5
+nombre3 apellidos3
+32154637K 15/06/03 8
+B
+2
+nombre4 apellidos4
+12345678X 15/06/01 9
+nombre5 apellidos5
+12225678F 15/06/01 9

Exámenes Resueltos (Segundo Semestre)/Junio2017ABC/CheckML.h

@@ -0,0 +1,8 @@
+#ifdef _DEBUG 
+#define _CRTDBG_MAP_ALLOC 
+#include <stdlib.h> 
+#include <crtdbg.h> 
+#ifndef DBG_NEW #define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ ) 
+#define new DBG_NEW 
+#endif 
+#endif 

Exámenes Resueltos (Segundo Semestre)/Junio2017ABC/ListaCitas.cpp

@@ -0,0 +1,91 @@
+#include "ListaCitas.h"
+using namespace std;
+
+//Funciones auxiliares:
+void ampliar(tListaCitas& listaCitas, int); //Amplia la lista de citas en caso de que se haya llegado al límite de su capacidad.
+bool buscar(tListaCitas& listaCitas, const tCita& cita, int& ini, int& fin, int& pos); //Búsqueda binaria y recursiva.
+
+void nuevaLista(tListaCitas& listaCitas) {
+	listaCitas.capacidad = 5;
+	listaCitas.cont = 0;
+	listaCitas.lista = new tCita[listaCitas.capacidad];
+}
+
+bool inserta(tListaCitas& listaCitas, const tCita& cita) {
+	bool insertado = false;
+	int ini = 0, fin = listaCitas.cont - 1, pos = 0;
+
+	if (listaCitas.cont == listaCitas.capacidad) {
+		ampliar(listaCitas, listaCitas.capacidad*2);
+	}
+	else {
+		if (!buscar(listaCitas, cita, ini, fin, pos)) {
+			for (int i = listaCitas.cont; i > pos; i--){
+				listaCitas.lista[i] = listaCitas.lista[i - 1];
+			}
+			listaCitas.lista[pos] = cita;
+			listaCitas.cont++;
+			insertado = true;
+		}
+		else {
+			listaCitas.lista[pos] = cita;
+		}
+	}
+
+	return insertado;
+}
+
+//
+bool buscar(tListaCitas& listaCitas, const tCita& cita, int& ini, int& fin, int& pos){
+	bool encontrado = false;
+
+	if (ini <= fin) {
+		pos = (ini + fin) / 2;
+		if (cita.valoracion < listaCitas.lista[pos].valoracion) {
+			fin = pos - 1;
+			encontrado = buscar(listaCitas, cita, ini, fin, pos);
+		}
+		else if(listaCitas.lista[pos].valoracion < cita.valoracion){
+			ini = pos + 1;
+			encontrado = buscar(listaCitas, cita, ini, fin, pos);
+		}
+		else {
+			encontrado = true;
+		}
+	}
+
+	return encontrado;
+}
+//
+
+void muestra(const tListaCitas& listaCitas) {
+	cout << "Lista de citas: " << endl;
+	for (int i = listaCitas.cont - 1; i >= 0; i--){
+		cout << setfill(char('-')) << setw(40) << "\n" << setfill(char(0));
+		mostrar(*listaCitas.lista[i].puntero1);
+		mostrar(*listaCitas.lista[i].puntero2);
+		cout << "Cita en: " << setw(10) << listaCitas.lista[i].lugar << setw(20) << "Valoración: " << listaCitas.lista[i].valoracion << endl;
+		cout << setfill(char('-')) << setw(40) << "\n" << setfill(char(0));
+	}
+}
+
+//
+void ampliar(tListaCitas& listaCitas, int ampliacion) {
+	listaCitas.capacidad = ampliacion;
+
+	tCita* aux;
+	aux = new tCita[listaCitas.capacidad];
+
+	for (int i = 0; i < listaCitas.cont; i++){
+		aux[i] = listaCitas.lista[i];
+	}
+	
+	delete[] listaCitas.lista;
+	listaCitas.lista = aux;
+
+}
+//
+
+void libera(tListaCitas& listaCitas) {
+	delete[] listaCitas.lista;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2017ABC/ListaCitas.h

@@ -0,0 +1,29 @@
+#ifndef _LISTACITAS
+#define _LISTACITAS
+
+#include "ListaClientes.h"
+
+//Constantes:
+
+
+//Tipos:
+typedef struct tCita {
+	tCliente *puntero1;
+	tCliente *puntero2;
+	std::string lugar;
+	int valoracion;
+};
+
+typedef struct tListaCitas {
+	tCita *lista; //Ordena por valoracion, de mayor a menor.
+	int cont;
+	int capacidad;
+};
+
+//Funciones:
+void nuevaLista(tListaCitas& listaCitas);
+bool inserta(tListaCitas& listaCitas, const tCita& cita); //const tCliente&, const tCliente&, std::string&, int&
+void muestra(const tListaCitas& listaCitas);
+void libera(tListaCitas& listaCitas);
+
+#endif // !_LISTACITAS

Exámenes Resueltos (Segundo Semestre)/Junio2017ABC/ListaClientes.cpp

@@ -0,0 +1,53 @@
+#include "ListaClientes.h"
+using namespace std;
+
+void mostrar(tCliente& cliente) {
+	cout << setw(10) << cliente.login
+		<< setw(15) << cliente.fechaAlta
+		<< setw(10) << cliente.edad << setw(2) << "años"
+		<< setw(10) << cliente.ciudad << endl;
+}
+
+bool cargar(tListaClientes& lista) {
+	bool carga = false;
+	ifstream archivo;
+	int i = 0;
+
+	lista.cont = 0;
+
+	archivo.open("clientes.txt");
+	if (!archivo.is_open()) {
+		cout << "Error al cargar los clientes." << endl;
+	}
+	else {
+		archivo >> i;
+		while (!archivo.fail() && lista.cont < i) {
+			lista.cliente[lista.cont] = new tCliente;
+			archivo >> lista.cliente[lista.cont]->login;
+			archivo >> lista.cliente[lista.cont]->fechaAlta;
+			archivo >> lista.cliente[lista.cont]->edad;
+			archivo >> lista.cliente[lista.cont]->ciudad;
+			lista.cont++;
+		}
+		carga = true;
+	}
+	
+	return carga;
+}
+
+void mostrar(tListaClientes& lista, int& i) { //Recursiva.
+
+	if (i < lista.cont) {
+		cout << setw(2) << i;
+		mostrar(*lista.cliente[i]);
+		i++;
+		mostrar(lista, i);
+	}
+}
+
+void liberar(tListaClientes& lista) {
+	for (int i = 0; i < lista.cont; i++){
+		delete lista.cliente[i];
+	}
+//	delete[] lista.cliente;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2017ABC/ListaClientes.h

@@ -0,0 +1,32 @@
+#ifndef _LISTACLIENTES
+#define _LISTACLIENTES
+
+#include <iostream>
+#include <string>
+#include <fstream>
+#include <iomanip>
+#include <stdlib.h>
+
+//Constantes:
+const int MAX_CLIENTES = 50;
+
+//Tipos:
+typedef struct tCliente {
+	std::string login, fechaAlta, ciudad;
+	int edad;
+
+};
+
+typedef struct tListaClientes {
+	tCliente *cliente[MAX_CLIENTES]; //NO ORDENADA.
+	int cont;
+};
+
+//Funciones:
+void mostrar(tCliente& cliente); 
+
+bool cargar(tListaClientes& lista);
+void mostrar(tListaClientes& lista, int&); //Recursiva
+void liberar(tListaClientes& lista);
+
+#endif // !

Exámenes Resueltos (Segundo Semestre)/Junio2017ABC/clientes.txt

@@ -0,0 +1,25 @@
+6
+Juan
+15/06/07
+42
+Madrid
+Luis
+15/06/08
+27
+Madrid
+Ana
+15/06/08
+18
+Avila
+Maria
+15/06/09
+23
+Burgos
+Javi
+15/06/14
+25
+Salamanca
+Marisa
+25/05/15
+40
+Madrid

Exámenes Resueltos (Segundo Semestre)/Junio2017ABC/main.cpp

@@ -0,0 +1,79 @@
+//Examen Junio 2017 - FP
+//Grupos A, B y C
+//Fernando Méndez Torrubiano
+
+#include "ListaCitas.h"
+#include "CheckML.h"
+using namespace std;
+
+//Funciones auxiliares:
+int menu(); //Muestra el menú de opciones.
+
+int main() {
+	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); //Muestra fugas de memoria.
+	system("chcp 1252"); //Castellano.
+	system("cls");
+
+	tListaCitas listaCitas;
+	tListaClientes lista;
+	tCliente cliente1, cliente2;
+	tCita cita;
+
+	int opc = -1;
+	int i = 0, c1, c2;
+
+	if (cargar(lista)) {
+		nuevaLista(listaCitas);
+		while (opc != 0){
+			opc = menu();
+			i = 0;
+			switch (opc){
+			case 1:
+				mostrar(lista, i);
+				break;
+			case 2:
+				mostrar(lista, i);
+				cout << "Cliente 1: ";
+				cin >> c1;
+				cita.puntero1 = lista.cliente[c1];
+				cout << "Cliente 2: ";
+				cin >> c2;
+				cita.puntero2 = lista.cliente[c2];
+				cout << "Lugar de la cita: ";
+				cin >> cita.lugar;
+				cout << "Valoración de la cita: ";
+				cin >> cita.valoracion;
+				inserta(listaCitas, cita);
+				break;
+			case 3: 
+				muestra(listaCitas);
+				break;
+			default:
+				break;
+			}
+		}
+	}
+	else {
+		cout << "Fin del programa." << endl;
+		system("PAUSE");
+	}
+	liberar(lista);
+	libera(listaCitas);
+
+	return 0;
+}
+
+int menu() {
+	int opc = 0;
+	cout << "1.-Mostrar lista de clientes." << endl;
+	cout << "2.-Nueva cita." << endl;
+	cout << "3.-Mostrar todas las citas (ordenasdas por valoración)." << endl;
+	cout << "0.-SALIR" << endl;
+
+	do {
+		cout << "Introduzca una opción:";
+		cin >> opc;
+	} while (opc < 0 || opc > 3);
+
+	return opc;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2017DG/CheckML.h

@@ -0,0 +1,12 @@
+#ifdef _DEBUG  
+#define _CRTDBG_MAP_ALLOC  
+
+#include <stdlib.h>  
+#include <crtdbg.h>  
+
+#ifndef DBG_NEW  
+#define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )  
+#define new DBG_NEW 
+
+#endif  
+#endif

Exámenes Resueltos (Segundo Semestre)/Junio2017DG/datos.txt

@@ -0,0 +1,5 @@
+S030514 Sardina 10.875 8.30
+B892310 Bacalao 5.750 10.50
+T231 Trucha 6.2 18.75
+K4356 Sardina 5.00 5.50
+GA65455 Pescadilla 15.35 9.30

Exámenes Resueltos (Segundo Semestre)/Junio2017DG/listaCompradores.cpp

@@ -0,0 +1,56 @@
+#include "listaCompradores.h"
+using namespace std;
+
+void iniciar(tListaComprador & lista){
+	lista.capacidad = 10;
+	lista.cont = 0;
+	lista.comprador = new tComprador*[lista.capacidad];
+}
+
+bool insertar(tListaComprador& lista, tComprador& comprador){
+	bool insertado = false;
+	int pos = 0;
+
+	if(!buscar(lista, comprador, pos)){
+		lista.comprador[lista.cont] = new tComprador;
+		lista.comprador[lista.cont]->id = comprador.id;
+		lista.comprador[lista.cont]->importe = comprador.importe;
+		lista.cont++;
+		insertado = true;
+	}
+	else {
+		lista.comprador[pos]->importe += comprador.importe;
+	}
+
+	return insertado;
+}
+
+bool buscar(tListaComprador & lista, tComprador& comprador, int& pos){
+	bool encontrado = false;
+
+	while (!encontrado &&  pos < lista.cont) {
+		if (lista.comprador[pos]->id == comprador.id) {
+			encontrado = true;
+		}
+		else {
+			pos++;
+		}
+	}
+
+	return encontrado;
+}
+
+void mostrar(tListaComprador & lista){
+	for (int i = 0; i < lista.cont; i++){
+		cout << right << setw(10) << "Comprador: " << lista.comprador[i]->id
+			<< setw(10) << "Total: " << lista.comprador[i]->importe << endl;
+	}
+}
+
+void liberar(tListaComprador & lista){
+	for (int i = 0; i < lista.cont; i++){
+		delete lista.comprador[i];
+	}
+
+	delete[] lista.comprador;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2017DG/listaCompradores.h

@@ -0,0 +1,29 @@
+#ifndef H_LISTACOMPRADORES_H
+#define H_LISTACOMPRADORES_H
+
+#include <iostream>
+#include <string>
+#include <fstream>
+#include <iomanip>
+#include <stdlib.h>
+
+//Constantes:
+
+//Tipos:
+typedef struct tComprador {
+	long long int id, importe;
+};
+
+typedef struct tListaComprador {
+	tComprador** comprador;
+	int cont, capacidad;
+};
+
+//Funciones:
+void iniciar(tListaComprador& lista);
+bool insertar(tListaComprador& lista, tComprador& comprador);
+bool buscar(tListaComprador& lista, tComprador& comprador, int& pos);
+void mostrar(tListaComprador& lista);
+void liberar(tListaComprador& lista);
+
+#endif // !H_LISTACOMPRADORES_H

Exámenes Resueltos (Segundo Semestre)/Junio2017DG/listaLonja.cpp

@@ -0,0 +1,115 @@
+#include "listaLonja.h"
+using namespace std;
+
+//Funciones auxiliares:
+bool busquedaRecursiva(tListaLotes & lista, tLotes& nuevo, int& ini, int& fin, int& pos);
+
+
+void inicializar(tListaLotes & lista){
+	lista.cont = 0;
+}
+
+int numLotes(tListaLotes & lista){
+	return lista.cont;
+}
+
+bool insertar(tListaLotes & lista, tLotes& nuevo){
+	bool insertado = false;
+	int pos = 0;
+
+
+	if (!buscar(lista, nuevo, pos)) {
+		lista.lote[lista.cont] = new tLotes;
+		lista.lote[lista.cont]->lote = nuevo.lote;
+		lista.lote[lista.cont]->tipo = nuevo.tipo;
+		lista.lote[lista.cont]->precio = nuevo.precio;
+		lista.lote[lista.cont]->peso = nuevo.peso;
+		lista.cont++;
+	}
+	else {
+		lista.lote[lista.cont] = new tLotes;
+		for (int i = lista.cont; i > pos; i--){
+			lista.lote[i] = lista.lote[i - 1];
+		}
+		lista.lote[pos]->tipo = nuevo.tipo;
+		lista.lote[pos]->lote = nuevo.lote;
+		lista.lote[pos]->precio = nuevo.precio;
+		lista.lote[pos]->peso = nuevo.peso;
+		lista.cont++;
+		insertado = true;
+	}
+
+	return insertado;
+}
+
+bool cargar(tListaLotes & lista){
+	bool carga = false;
+	ifstream archivo;
+	tLotes aux;
+	inicializar(lista);
+
+	archivo.open("datos.txt");
+	if (!archivo.is_open()) {
+		cout << "Error al caragar el archivo." << endl;
+	}
+	else {
+		while (!archivo.fail() && lista.cont < MAX_LOTES) {
+			archivo >> aux.lote;
+			archivo >> aux.tipo;
+			archivo >> aux.precio;
+			archivo >> aux.peso;
+			if (!archivo.eof()) {
+				insertar(lista, aux);
+			}
+		}
+		carga = true;
+	}
+
+	return carga;
+}
+
+bool buscar(tListaLotes& lista, tLotes& nuevo, int& pos){
+	bool encontrado = false;
+	int ini = 0, fin = lista.cont - 1;
+
+	encontrado = busquedaRecursiva(lista, nuevo, ini, fin, pos);
+
+	return encontrado;
+}
+
+bool busquedaRecursiva(tListaLotes& lista, tLotes& nuevo, int& ini, int& fin, int& pos) {
+	bool encontrado = false;
+
+	if (ini <= fin) {
+		pos = (ini + fin) / 2;
+		if (nuevo < *lista.lote[pos]) {
+			fin = pos - 1;
+			encontrado = busquedaRecursiva(lista, nuevo, ini, fin, pos);
+		}
+		else if (*lista.lote[pos] < nuevo){
+			ini = pos + 1;
+			encontrado = busquedaRecursiva(lista, nuevo, ini, fin, pos);
+		}
+		else {
+			encontrado = true;
+		}
+	}
+
+	return encontrado;
+}
+
+void obeternerLote(tListaLotes& lista, tLotes* lote, int& pos){
+	lote = lista.lote[pos];
+}
+
+void mostrar(tListaLotes& lista, tListaComprador& comprador){
+	for (int i = 0; i < comprador.cont; i++){
+		mostrarPrecio(*lista.lote[i], *comprador.comprador[i]);
+	}
+}
+
+void liberar(tListaLotes & lista){
+	for (int i = 0; i < lista.cont; i++){
+		delete lista.lote[i];
+	}
+}

Exámenes Resueltos (Segundo Semestre)/Junio2017DG/listaLonja.h

@@ -0,0 +1,23 @@
+#ifndef H_LISTALONJA_H
+#define H_LISTALONJA_H
+
+#include "lotes.h"
+
+//Constantes:
+
+//Tipos:
+typedef struct tListaLotes {
+	tLotes* lote[MAX_LOTES];
+	int cont;
+};
+//Funciones:
+void inicializar(tListaLotes& lista);
+int numLotes(tListaLotes& lista);
+bool insertar(tListaLotes& lista, tLotes& nuevo);
+bool cargar(tListaLotes& lista);
+bool buscar(tListaLotes& lista, tLotes& nuevo, int& pos); //Implementación recursiva y binaria.
+void obeternerLote(tListaLotes& lista, tLotes* lote, int& pos);
+void mostrar(tListaLotes& lista, tListaComprador& comprador);
+void liberar(tListaLotes& lista);
+
+#endif // !H_LISTALONJA_H

Exámenes Resueltos (Segundo Semestre)/Junio2017DG/lotes.cpp

@@ -0,0 +1,28 @@
+#include "lotes.h"
+#include "listaCompradores.h"
+using namespace std; 
+
+bool operator<(tLotes& loteIzq, tLotes& loteDer){
+	return (loteIzq.tipo < loteDer.tipo);
+}
+
+bool operator==(tLotes& loteIzq, tLotes& loteDer){
+	return (loteIzq.id == loteDer.id);
+}
+
+void mostrarLote(const tLotes& lote){
+	cout << right << setw(15) << "Lote: " << lote.lote
+		<< setw(25) << setprecision(2) << "Peso del lote: " << lote.peso << endl
+		<< setw(15) << "Tipo: " << lote.tipo << setw(25) << "Precio de salida: " << lote.precio << endl << endl;
+}
+
+void mostrarPrecio(tLotes & lote, tComprador& comprador){
+	cout << right << setw(15) << "Lote: " << lote.lote
+		<< setw(25) << setprecision(2) << "Comprador: " << comprador.id << endl
+		<< setw(15) << "Tipo: " << lote.tipo << setw(25) << "Precio de compra: " << comprador.importe << endl;
+}
+
+void modificarLote(tLotes & lote, long long int& id, float& precio){
+	lote.id = id;
+	lote.precio = precio;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2017DG/lotes.h

@@ -0,0 +1,29 @@
+#ifndef H_LOTES_H
+#define H_LOTES_H
+
+#include <iostream>
+#include <string>
+#include <fstream>
+#include <iomanip>
+#include <stdlib.h>
+#include "listaCompradores.h"
+
+//Constantes:
+const int MAX_LOTES = 300;
+
+//Tipos:
+typedef struct tLotes {
+	std::string lote, tipo;
+	float peso, precio;
+	long long int id;
+};
+
+//Funciones:
+bool operator<(tLotes& loteIzq, tLotes& loteDer);
+bool operator==(tLotes& loteIzq, tLotes& loteDer);
+void mostrarLote(const tLotes& lote);
+void mostrarPrecio(tLotes& lote, tComprador& comprador);
+void modificarLote(tLotes& lote, long long int& id, float& precio);
+
+#endif // !H_LOTES_H
+

Exámenes Resueltos (Segundo Semestre)/Junio2017DG/main.cpp

@@ -0,0 +1,41 @@
+//Examen Junio 2017 - FP
+//Grupos D y G
+//Fernando Méndez Torrubiano
+
+using namespace std;
+#include "listaLonja.h"
+#include "CheckML.h"
+
+int main() {
+	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); //Detecta posibles fugas de memoria.
+	system("chcp 1252"); //Castellano
+	system("cls");
+
+	tListaLotes listaLotes;
+	tListaComprador listaComprador;
+	iniciar(listaComprador);
+	tComprador aux;
+	int i = 0;
+
+	if (cargar(listaLotes)) {
+		while (i < listaLotes.cont) {
+			mostrarLote(*listaLotes.lote[i]);
+			cout << "Introduzca comprador y precio: ";
+			cin >> aux.id;
+			cin >> aux.importe;
+			insertar(listaComprador, aux);
+			i++;
+		}
+		mostrar(listaComprador);
+		mostrar(listaLotes, listaComprador);
+	}
+	else {
+		cout << "Error al cargar la lista." << endl;
+	}
+	system("PAUSE");
+
+	liberar(listaLotes);
+	liberar(listaComprador);
+
+	return 0;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2018AB/checkML.h

@@ -0,0 +1,9 @@
+#ifdef _DEBUG
+#define _CRTDBG_MAP_ALLOC
+#include <stdlib.h>
+#include <crtdbg.h>
+#ifndef DBG_NEW
+#define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )
+#define new DBG_NEW
+#endif
+#endif

Exámenes Resueltos (Segundo Semestre)/Junio2018AB/coordenada.cpp

@@ -0,0 +1,46 @@
+#include "coordenada.h"
+
+tCoordenada crearCoordenada(int f, int c)
+{
+	tCoordenada coordenada;
+	coordenada._fila = f; coordenada._columna = c;
+	return coordenada;
+}
+
+
+bool operator== (const tCoordenada &c1, const tCoordenada &c2)
+{
+	return c1._fila == c2._fila && c1._columna == c2._columna;
+}
+
+bool operator!= (const tCoordenada &c1, const tCoordenada &c2)
+{
+	return !(c1 == c2);
+}
+
+int fila(const tCoordenada &c){
+	return c._fila;
+}
+int columna(const tCoordenada &c)
+{
+	return c._columna;
+}
+
+void calcularCoordenada(const tCoordenada & c, int dir, tCoordenada & nc)
+{
+	if ((0 <= dir) && (dir <= 2)) { nc._fila = c._fila - 1; }
+	else if ((dir == 3) || (dir == 7)) { nc._fila = c._fila; }
+	else { nc._fila = c._fila + 1; }
+	switch (dir)
+	{
+	case 0:
+	case 6:
+	case 7:
+		nc._columna = c._columna - 1; break;
+	case 1:
+	case 5: nc._columna = c._columna; break;
+	default: nc._columna = c._columna + 1;
+		break;
+	}
+
+}

Exámenes Resueltos (Segundo Semestre)/Junio2018AB/coordenada.h

@@ -0,0 +1,32 @@
+#ifndef _coordenada
+#define _coordenada
+
+using namespace std;
+
+typedef struct { int _fila; int _columna; } tCoordenada;
+
+
+//Dada una fila y una columna construye una coordenada con ellas
+tCoordenada crearCoordenada(int f, int c);
+
+//Consulta la componente fila de una coordenada
+int fila(const tCoordenada &c);
+
+//Consulta la componente columna de una coordenada
+int columna(const tCoordenada &c);
+
+
+//Dada una coordenada y una dirección(entre 0 y 7 inclusive), 
+//calcula una nueva coordenada en la dirección indicada, segun el siguiente dibujo
+// 0 1 2
+// 7   3
+// 6 5 4
+//Esta funcion no comprueba si la nueva coordenada esta dentro de los limites del jardin.
+void calcularCoordenada(const tCoordenada & c, int dir, tCoordenada & nc);
+
+//Funciones para comprobar la igualdad o desigualdad de dos coordenadas
+bool operator== (const tCoordenada &c1, const tCoordenada &c2);
+bool operator!= (const tCoordenada &c1, const tCoordenada &c2);
+
+
+#endif

Exámenes Resueltos (Segundo Semestre)/Junio2018AB/jardin.cpp

@@ -0,0 +1,93 @@
+#include "jardin.h"
+using namespace std;
+
+bool cargarJardin(tJardin& jardin, ifstream& archivo) {
+	bool carga = false;
+	int F, C;
+	//ifstream archivo;
+
+	//archivo.open(jardin);
+	//if (!archivo.is_open()) {
+	//	cout << "No se ha podido cargar el jardin." << endl;
+	//}
+	//else {
+	archivo >> jardin.numF;
+	archivo >> jardin.numC;
+		for (int i = 0; i < jardin.numF; i++){
+			for (int j = 0; j < jardin.numC; j++){
+				archivo >> jardin.parcela[i][j].aguaNecesaria;
+				jardin.parcela[i][j].aguaRegada = 0;
+			}
+		}
+		carga = true;
+	//}
+	//archivo.close();
+
+	return carga;
+}
+
+void mostrarJardin(tJardin& jardin) {
+	for (int i = 0; i < jardin.numF; i++){
+		for (int j = 0; j < jardin.numC; j++){
+			cout << jardin.parcela[i][j].aguaNecesaria << " ";
+		}
+		cout << endl;
+	}
+}
+
+void regar(tJardin& jardin, tCoordenada& coordenada) {
+	tCoordenada nc;
+
+	for (int i = 0; i < 8; i++){
+		calcularCoordenada(coordenada, i, nc);
+		jardin.parcela[nc._fila][nc._columna].aguaRegada++;
+	}
+}
+
+int calcularPuntuacion(tJardin& jardin) {
+	int puntos = 0;
+
+	for (int i = 0; i < jardin.numF; i++){
+		for (int j = 0; j < jardin.numC; j++){
+			if (jardin.parcela[i][j].aguaRegada > jardin.parcela[i][j].aguaNecesaria) {
+				puntos += (jardin.parcela[i][j].aguaRegada - jardin.parcela[i][j].aguaNecesaria);
+			}
+			else if (jardin.parcela[i][j].aguaRegada == jardin.parcela[i][j].aguaNecesaria) {
+				puntos += jardin.parcela[i][j].aguaNecesaria;
+			}
+		}
+	}
+
+	return puntos;
+}
+
+bool plantaCondenada(tJardin& jardin, tCoordenada& coordenada) {
+	bool encontrada = false;
+	int i = -1, j = 0;
+	
+	while (!encontrada && i < jardin.numF) {
+		i++;
+		while (!encontrada && j < jardin.numC) {
+			if (jardin.parcela[i][j].aguaNecesaria < jardin.parcela[i][j].aguaRegada) {
+				encontrada = true;
+			}
+			else {
+				j++;
+			}
+		}
+	}
+
+	coordenada = crearCoordenada(i, j);
+
+	return encontrada;
+}
+
+bool esLibre(const tJardin& jardin, tCoordenada coordenada) {
+	bool libre = false;
+
+	if (coordenada._fila < jardin.numF && coordenada._columna < jardin.numC && jardin.parcela[coordenada._fila][coordenada._columna].aguaNecesaria == 0) {
+		libre = true;
+	}
+
+	return libre;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2018AB/jardin.h

@@ -0,0 +1,33 @@
+#ifndef _JARDIN
+#define _JARDIN
+
+#include "coordenada.h"
+#include <iostream>
+#include <string>
+#include <fstream>
+#include <iomanip>
+
+//Constantes:
+const int DIM = 50;
+
+//Tipos:
+typedef struct tParcela{
+	int aguaNecesaria;
+	int aguaRegada;
+};
+
+typedef struct tJardin {
+	tParcela parcela[DIM][DIM];
+	int numF, numC;
+};
+
+//Funciones:
+bool cargarJardin(tJardin& jardin, std::ifstream& archivo);
+void mostrarJardin(tJardin& jardin);
+void regar(tJardin& jardin, tCoordenada& coordenada);
+int calcularPuntuacion(tJardin& jardin);
+bool plantaCondenada(tJardin& jardin, tCoordenada& coordenada);
+bool esLibre(const tJardin& jardin, tCoordenada coordenada);
+
+
+#endif // !_JARDIN

Exámenes Resueltos (Segundo Semestre)/Junio2018AB/jardin.txt

@@ -0,0 +1,6 @@
+5 8
+5 0 0 0 0 0 0 3
+0 0 0 6 0 0 0 0
+0 8 0 0 0 1 0 2
+0 0 0 0 0 0 0 0
+0 3 0 0 0 5 0 0

Exámenes Resueltos (Segundo Semestre)/Junio2018AB/jugadores.txt

@@ -0,0 +1,5 @@
+Alberto 8
+Clara 5
+Susana 17
+Tadeo 8
+Victor 2

Exámenes Resueltos (Segundo Semestre)/Junio2018AB/listaCoordenadas.cpp

@@ -0,0 +1,50 @@
+#include "listaCoordenadas.h"
+using namespace std;
+
+void crearVacia(tListaCoordenadas& listaCoor) {
+	for (int i = 0; i < MAX_COORDENADAS; i++){
+		listaCoor.coordenada[i]._fila = 0;
+		listaCoor.coordenada[i]._columna = 0;
+	}
+	listaCoor.cont = 0;
+}
+
+bool buscar(tListaCoordenadas& listaCoor, tCoordenada& coordenada) {
+	bool encontrada = false;
+	int i = 0;
+
+	while (!encontrada && i < listaCoor.cont) {
+		if (listaCoor.coordenada[i] == coordenada) {
+			encontrada = true;
+		}
+		else {
+			i++;
+		}
+	}
+
+	return encontrada;
+}
+
+bool insertar(tListaCoordenadas& listaCoor, tCoordenada& coor) {
+	bool insertado = false;
+
+	if (!buscar(listaCoor, coor)) {
+		listaCoor.coordenada[listaCoor.cont] = coor;
+		listaCoor.cont++;
+		insertado = true;
+	}
+
+	return insertado;
+}
+
+bool sacar(tListaCoordenadas& listaCoor, tCoordenada& coor) {
+	bool sacada = false;
+
+	if (listaCoor.cont > 1) {
+		coor = listaCoor.coordenada[listaCoor.cont];
+		listaCoor.cont--;
+		sacada = true;
+	}
+
+	return sacada;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2018AB/listaCoordenadas.h

@@ -0,0 +1,21 @@
+#ifndef _LISTACOORDENADAS
+#define _LISTACOORDENADAS
+
+#include "jardin.h"
+
+//Constantes:
+const int MAX_COORDENADAS = DIM * DIM;
+
+//Tipos:
+typedef struct tListaCoordenadas {
+	tCoordenada coordenada[MAX_COORDENADAS];
+	int cont;
+};
+
+//Funciones:
+void crearVacia(tListaCoordenadas& listaCoor);
+bool buscar(tListaCoordenadas& listaCoor, tCoordenada& coordenada);
+bool insertar(tListaCoordenadas& listaCoor, tCoordenada& coor);
+bool sacar(tListaCoordenadas& listaCoor, tCoordenada& coor);
+
+#endif // !_LISTACOORDENADAS

Exámenes Resueltos (Segundo Semestre)/Junio2018AB/listaJugadores.cpp

@@ -0,0 +1,140 @@
+#include "listaJugadores.h"
+using namespace std;
+
+//Funciones auxiliares:
+bool buscarBinaria(tListaJugadores& jugadores, std::string nombre, int& ini, int& fin, int& pos);
+
+void iniciar(tListaJugadores& lista) {
+	lista.cont = 0;
+	lista.capacidad = 10;
+	lista.jugador = new tJugador*[lista.capacidad];
+}
+
+bool cargarJugadores(tListaJugadores& lista, ifstream& archivo) {
+	bool carga = false;
+	//ifstream archivo;
+
+	iniciar(lista);
+
+	//archivo.open(nomArchivo);
+	//if (!archivo.is_open()) {
+	//	cout << "Error al cargar la lista de jugadores." << endl;
+	//}
+	//else {
+		while (!archivo.fail()) {
+				lista.jugador[lista.cont] = new tJugador;
+				archivo >> lista.jugador[lista.cont]->nombre;
+				archivo >> lista.jugador[lista.cont]->puntos;
+				lista.cont++;
+		}
+		lista.cont--;
+		carga = true;
+	//}
+	//archivo.close();
+
+	return carga;
+}
+
+bool guardarJugadores(tListaJugadores& lista, ofstream& archivo) {
+	bool guardado = false;
+	//ofstream archivo;
+
+	//archivo.open(nomArchivo);
+	//if (!archivo.is_open()) {
+	//	cout << "No se pueden guardar los jugadores." << endl;
+	//}
+	//else {
+		for (int i = 0; i < lista.cont; i++){
+			archivo << lista.jugador[i]->nombre << " "
+				<< lista.jugador[i]->puntos << endl;
+		}
+	//}
+	//archivo.close();
+
+	return guardado;
+}
+
+void mostrarJugadores(const tListaJugadores& jugadores) {
+	for (int i = 0; i < jugadores.cont; i++) {
+		cout << right << setw(15) << jugadores.jugador[i]->nombre
+			<< setw(5) << jugadores.jugador[i]->puntos << endl;
+	}
+	system("PAUSE");
+}
+
+bool buscar(tListaJugadores& jugadores, std::string nombre, int& pos) {
+	bool encontrado = false;
+	int ini = 0, fin = jugadores.cont - 1;
+	pos = 0;
+
+	encontrado = buscarBinaria(jugadores, nombre, ini, fin, pos);
+
+	return encontrado;
+}
+
+bool buscarBinaria(tListaJugadores& jugadores, std::string nombre, int& ini, int& fin, int& pos) {
+	bool encontrado = false;
+
+	if (ini <= fin) {
+		pos = (ini + fin) / 2;
+		if (nombre < jugadores.jugador[pos]->nombre) {
+			fin = pos - 1;
+			encontrado = buscarBinaria(jugadores, nombre, ini, fin, pos);
+		}
+		else if (jugadores.jugador[pos]->nombre < nombre) {
+			ini = pos + 1;
+			encontrado = buscarBinaria(jugadores, nombre, ini, fin, pos);
+		}
+		else {
+			encontrado = true;
+		}
+	}
+
+	return encontrado;
+}
+
+void actualizarPuntuacion(tListaJugadores& jugadores, string nombre, int puntos) {
+	int pos = 0;
+
+	if (!buscar(jugadores, nombre, pos)) {
+		for (int i = jugadores.cont; i >= pos; i--) {
+			jugadores.jugador[i] = jugadores.jugador[i - 1];
+		}
+		jugadores.cont++;
+		jugadores.jugador[pos] = new tJugador;
+	}
+	jugadores.jugador[pos]->nombre = nombre;
+	jugadores.jugador[pos]->puntos = puntos;
+}
+
+void mostrarPorPuntos(const tListaJugadores& lista) {
+	int cont;
+	tListaJugadores aux;
+
+	aux.cont = lista.cont + 1;
+	aux.capacidad = lista.capacidad;
+	aux.jugador = new tJugador*[aux.capacidad];
+	
+	for (int i = 0; i < lista.cont; i++){
+		cont = i;
+		aux.jugador[i] = lista.jugador[i];
+		while (cont > 0 && aux.jugador[cont - 1]->puntos < aux.jugador[cont]->puntos) {
+			aux.jugador[aux.cont] = aux.jugador[cont];
+			aux.jugador[cont] = aux.jugador[cont - 1];
+			aux.jugador[cont - 1] = aux.jugador[aux.cont];
+			cont--;
+		}
+	}
+
+	aux.cont = lista.cont;
+	mostrarJugadores(aux);
+
+	delete[] aux.jugador;
+}
+
+void liberar(tListaJugadores& jugadores) {
+	for (int i = 0; i < jugadores.cont; i++){
+		delete jugadores.jugador[i];
+	}
+	delete[] jugadores.jugador;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2018AB/listaJugadores.h

@@ -0,0 +1,31 @@
+#ifndef _LISTAJUGADORES
+#define _LISTAJUGADORES
+
+#include "listaCoordenadas.h"
+
+//Constantes:
+
+
+//Tipos:
+typedef struct tJugador {
+	std::string nombre;
+	int puntos;
+};
+
+typedef struct tListaJugadores {
+	tJugador **jugador; //Ordenada por nombre y sin nombres repetidos.
+	int cont;
+	int capacidad;
+};
+
+//Funciones:
+void iniciar(tListaJugadores& lista);
+bool cargarJugadores(tListaJugadores& lista, std::ifstream& archivo);
+bool guardarJugadores(tListaJugadores& lista, std::ofstream& archivo);
+void mostrarJugadores(const tListaJugadores& jugadores);
+bool buscar(tListaJugadores& jugadores, std::string nombre, int& pos); //Binaria y recursiva.
+void actualizarPuntuacion(tListaJugadores& jugadores, std::string nombre, int puntos);
+void mostrarPorPuntos(const tListaJugadores& jugadores);
+void liberar(tListaJugadores& jugadores);
+
+#endif // !_LISTAJUGADORES

Exámenes Resueltos (Segundo Semestre)/Junio2018AB/main.cpp

@@ -0,0 +1,222 @@
+#include "listaCoordenadas.h"
+#include "listaJugadores.h"
+#include "jardin.h"
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+
+
+void mostrarMenu(); //menu principal
+void mostrarMenu2(); //menu para mostrar: opcion 2
+int leerOpcion(int ini, int fin); //entre los valores ini y fin
+string leerNombreFichero(); 
+
+
+void ejecutarJuego(tListaJugadores &js); //ejecutar opcion 1
+void leerCoordenadas(const tJardin &j, tListaCoordenadas &cs); //leer las coordenadas de los aspersores
+void regarJardin(tJardin & j, tListaCoordenadas &cs); //regar todo el jardin: consume la lista de coordenadas
+
+
+void ejecutarMostrarJugadores(const tListaJugadores &js); //ejecutar opcion 2
+
+void ejecutarPlantaCondenada(); //ejecutar opcion 3
+
+
+
+
+
+
+
+int main()
+{
+	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
+
+	tListaJugadores js;
+	ifstream ijugadores;
+    //Cargar los jugadores
+	ijugadores.open("jugadores.txt");
+	if (ijugadores.is_open()){
+		cargarJugadores(js, ijugadores);
+	}
+	else { cout << "No se ha podido cargar fichero.";}
+	ijugadores.close();
+
+	int op,op2;
+	
+	do{
+	
+	mostrarMenu();
+	op = leerOpcion(0,3);
+	switch (op){
+	case 0: cout << "Adios."; system("pause"); break;
+	case 1: ejecutarJuego(js); break;
+	case 2:ejecutarMostrarJugadores(js); break;
+	case 3: ejecutarPlantaCondenada(); break;	     
+	default: break;
+	}
+	} while (op != 0);
+
+
+
+
+	//Guardar los jugadores
+	ofstream ofjugadores;
+	ofjugadores.open("jugadores.txt");
+	guardarJugadores(js, ofjugadores);
+	ofjugadores.close();
+
+	liberar(js);
+}
+
+
+void leerCoordenadas(const tJardin &j, tListaCoordenadas &cs){
+	int fila, columna;
+	tCoordenada c;
+
+	cout << "Introduzca las coordenadas. Para terminar introduzca -1. \n";
+
+
+	crearVacia(cs);
+
+	cout << "Coordenada: ";
+	cin >> fila;
+	while (!cin.fail() && fila != -1)
+	{
+		cin >> columna;
+		c = crearCoordenada(fila, columna);
+
+		if (esLibre(j, c))
+		{
+			if (!insertar(cs, c)) {
+				cout << "Repetida. \n";
+			}
+		}
+		else { cout << "Esa parcela no está libre.\n"; }
+
+		cout << "Coordenada: ";
+		cin >> fila;
+
+	}
+}
+
+
+
+
+void regarJardin(tJardin & j, tListaCoordenadas &cs)
+{
+	int puntos; tCoordenada c;
+	while (sacar(cs,c))
+	{
+		regar(j, c);
+	};
+
+}
+
+void mostrarMenu()
+{
+	system("cls");
+	cout << "1. Jugar." << endl;
+	cout << "2. Mostrar jugadores." << endl;
+	cout << "3. Planta condenada?." << endl;
+	cout << "0.Salir." << endl;
+	cout << "Introduce una opcion: ";
+
+}
+
+void mostrarMenu2()
+{
+	system("cls");
+	cout << "1. Mostrar jugadores ordenados por nombre." << endl;
+	cout << "2. Mostrar jugadores ordenados por puntuacion." << endl;
+	cout << "0.Volver." << endl;
+	cout << "Introduce una opcion: ";
+
+}
+
+int leerOpcion(int ini, int fin)
+{
+	int i;
+	cin >> i;
+	while (cin.fail() || i<ini || i>fin)
+	{
+		cin.clear(); cin.sync();
+		cout << "Opcion incorrecta. Introduce una opcion:";
+		cin >> i;
+	};
+	cin.sync();
+	return i;
+}
+
+
+string leerNombreFichero()
+{
+	string nfichero;
+	cout << "Introduce el nombre del fichero: ";
+	cin >> nfichero;
+	return nfichero;
+
+}
+
+
+
+
+void ejecutarPlantaCondenada()
+{
+
+	tJardin j; tCoordenada c;
+	string nfichero = leerNombreFichero();
+	ifstream fjardin;
+	fjardin.open(nfichero);
+	if (fjardin.is_open())
+	{
+		cargarJardin(j, fjardin);
+		if (plantaCondenada(j, c)) { cout << "Tiene al menos una planta condenada, en la coordenada: " << fila(c) << " " << columna(c) << endl; }
+		else { cout << "No tiene plantas condenadas.\n"; }
+	}
+	else { cout << "No se ha podido abrir.\n"; }
+	system("pause");
+}
+
+
+void ejecutarMostrarJugadores(const tListaJugadores &js)
+{
+	int op;
+	mostrarMenu2();
+	op = leerOpcion(0, 2);
+	if (op == 1) {
+		mostrarJugadores(js);
+	}
+	else if (op == 2) {
+		mostrarPorPuntos(js);
+	}
+}
+
+
+void ejecutarJuego(tListaJugadores &js)
+{
+	string nombre, njardin;
+	ifstream fjardin;
+	tJardin j;
+	tListaCoordenadas cs;
+	int puntos;
+
+	cout << "Introduzca el nombre del jugador: ";
+	cin >> nombre;
+	njardin = leerNombreFichero();
+	fjardin.open(njardin);
+	if (fjardin.is_open())
+	{
+		cargarJardin(j, fjardin);
+		mostrarJardin(j);
+		leerCoordenadas(j, cs);
+		regarJardin(j, cs);
+		puntos = calcularPuntuacion(j);
+		cout << nombre << ", has conseguido " << puntos << " puntos!.\n";
+		system("pause");
+		actualizarPuntuacion(js, nombre, puntos);
+	}
+	else { cout << "No se ha podido abrir."; }
+	fjardin.close();
+}
+

Exámenes Resueltos (Segundo Semestre)/Junio2018CEG/Departamentos.cpp

@@ -0,0 +1,52 @@
+#include "Departamentos.h"
+using namespace std;
+
+void inicializar(tDepartamento& departamento, std::string& id) {
+	departamento.cont = 0;
+	departamento.id = id;
+	departamento.empleado = new tEmpleado[MAX_EMPLEADOS];
+}
+
+int buscarEmpleado(tDepartamento& departamento, std::string& nif) {
+	int pos = departamento.cont - 1;
+	bool encontrado = false;
+
+	while (!encontrado && pos >= 0) {
+		if (departamento.empleado[pos].puntero->nif == nif) {
+			encontrado = true;
+		}
+		else {
+			pos--;
+		}
+	}
+
+	return pos;
+}
+
+bool insertarEmpleado(tListaContratos& contratos, tDepartamento& departamento, int& pos) {
+	bool insertado = false;
+	int i = buscarEmpleado(departamento, contratos.contrato[pos]->nif);
+
+	if (i == -1) {
+		departamento.empleado[departamento.cont].puntero = contratos.contrato[pos];
+		departamento.cont++;
+		departamento.empleado->numero = departamento.cont;
+		insertado = true;
+	}
+
+	return insertado;
+}
+
+void mostrarEmpleado(tEmpleado& empleado, int& i) {
+	cout << right << setw(3) << i+1 << ".-" << setw(25) << empleado.puntero->nombre << setw(10) << "num.: " << empleado.numero << endl;
+}
+
+void mostrarDepartamentos(tDepartamento& departamento) {
+	for (int i = 0; i < departamento.cont; i++){
+		mostrarEmpleado(departamento.empleado[i], i);
+	}
+}
+
+void liberar(tDepartamento& departamento) {
+	delete[] departamento.empleado;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2018CEG/Departamentos.h

@@ -0,0 +1,30 @@
+#ifndef H_DEPARTAMENTOS_H
+#define H_DEPAETAMENTOS_H
+
+#include "ListaContratos.h"
+
+//Constantes:
+const int MAX_EMPLEADOS = 50;
+
+//Tipos:
+typedef struct tEmpleado {
+	tContrato *puntero;
+	int numero;
+};
+
+typedef struct tDepartamento {
+	tEmpleado *empleado;
+	int cont;
+	std::string id;
+};
+
+//Funciones:
+void inicializar(tDepartamento& departamento, std::string& id);
+int buscarEmpleado(tDepartamento& departamento, std::string& nif);
+bool insertarEmpleado(tListaContratos& contratos, tDepartamento& departamento, int&);
+void mostrarEmpleado(tEmpleado& empleado, int& pos);
+void mostrarDepartamentos(tDepartamento& departamento);
+void liberar(tDepartamento& departamento);
+
+#endif // !H_DEPARTAMENTOS_H
+

Exámenes Resueltos (Segundo Semestre)/Junio2018CEG/ListaContratos.cpp

@@ -0,0 +1,103 @@
+#include "ListaContratos.h"
+using namespace std;
+
+//Funciones auxiliares:
+bool buscar(tListaContratos& lista, string& nif, int& ini, int& fin, int& pos);
+
+bool cargarContratos(tListaContratos& lista, tPrioridades& prioridades) {
+	bool carga = false;
+	ifstream archivo;
+	int numContratos = 0;
+
+	lista.cont = 0;
+
+	archivo.open("contratos.txt");
+	if (!archivo.is_open()) {
+		cout << "Error al cargar los contratos." << endl;
+	}
+	else {
+		archivo >> numContratos;
+		archivo.ignore();
+		while(!archivo.fail() && lista.cont < numContratos){
+			lista.contrato[lista.cont] = new tContrato;
+			if (insertarContrato(lista, prioridades, archivo)) {
+				lista.cont++;
+			}
+		}
+		carga = true;
+	}
+	archivo.close();
+
+	return carga;
+}
+
+bool insertarContrato(tListaContratos& lista, tPrioridades& prioridades, ifstream& archivo) {
+	bool insertado = false;
+	int ini = 0, fin = lista.cont - 1, pos = 0, numTareas = 0;
+
+	if (!buscar(lista, lista.contrato[lista.cont]->nif, ini, fin, pos)) {
+		getline(archivo, lista.contrato[lista.cont]->nombre);
+		archivo >> lista.contrato[lista.cont]->nif;
+		archivo >> lista.contrato[lista.cont]->sueldo;
+		archivo >> numTareas;
+		lista.contrato[lista.cont]->lista.cont = 0;
+		while (!archivo.fail() && lista.contrato[lista.cont]->lista.cont < numTareas) {
+			if (cargarTareas(lista.contrato[lista.cont]->lista, prioridades, archivo)) {
+				lista.contrato[lista.cont]->lista.cont++;
+			}
+		}
+		insertado = true;
+	}
+
+	return insertado;
+}
+
+//
+bool buscar(tListaContratos& lista, string& nif, int& ini, int& fin, int& pos) {
+	bool encontrado = false;
+
+	if (ini <= fin) {
+		pos = (ini + fin) / 2;
+		if (nif < lista.contrato[pos]->nif) {
+			fin = pos - 1;
+			encontrado = buscar(lista, lista.contrato[lista.cont]->nif, ini, fin, pos);;
+		}
+		else if (lista.contrato[pos]->nif < nif) {
+			ini = pos + 1;
+			encontrado = buscar(lista, lista.contrato[lista.cont]->nif, ini, fin, pos);;
+		}
+		else {
+			encontrado = true;
+		}
+	}
+
+	return encontrado;
+}
+//
+
+void mostrarContratos(tListaContratos& lista) {
+	for (int i = 0; i < lista.cont; i++){
+		cout << right << setw(3) << i + 1 << ".-"
+			<< setw(30) << lista.contrato[i]->nombre
+			<< setw(15) << lista.contrato[i]->nif
+			<< setw(5) << "(" << lista.contrato[i]->lista.cont << ")"
+			<< setw(10) << fixed << setprecision(2) << lista.contrato[i]->sueldo << endl;
+	}
+}
+
+int seleccionarContratos(tListaContratos& lista) {
+	int linea = 0;
+
+	mostrarContratos(lista);
+	cout << endl << "Introduzca el número la linea del contrato que desea seleccionar: ";
+	cin >> linea;
+	linea--;
+
+	return linea;
+}
+
+void liberar(tListaContratos& lista) {
+	for (int i = 0; i < lista.cont; i++){
+		delete lista.contrato[i];
+	}
+}

Exámenes Resueltos (Segundo Semestre)/Junio2018CEG/ListaContratos.h

@@ -0,0 +1,29 @@
+#ifndef H_LISTACONTRATOS_H
+#define H_LISTACONTRATOS_H
+
+#include"ListaTareas.h"
+
+//Constantes:
+const int MAX_CONTRATOS = 100;
+
+//Tipos:
+typedef struct tContrato {
+	std::string nombre, nif;
+	tListaTareas lista;
+	double sueldo;
+};
+
+typedef struct tListaContratos {
+	tContrato *contrato[MAX_CONTRATOS]; //Ordenados por NIF.
+	int cont;
+};
+
+//Funciones:
+bool cargarContratos(tListaContratos& lista, tPrioridades& prioridades);
+bool insertarContrato(tListaContratos& lista, tPrioridades& prioridades, std::ifstream& archivo);
+void mostrarContratos(tListaContratos& lista);
+int seleccionarContratos(tListaContratos& lista);
+void liberar(tListaContratos& lista);
+
+
+#endif // !H_LISTACONTRATOS_H

Exámenes Resueltos (Segundo Semestre)/Junio2018CEG/ListaTareas.cpp

@@ -0,0 +1,61 @@
+#include "ListaTareas.h"
+using namespace std;
+
+bool cargarPrioridades(tPrioridades& prioridad) {
+	bool carga = false;
+	ifstream archivo;
+
+	archivo.open("prioridades.txt");
+	if (!archivo.is_open()) {
+		cout << "Error al cargar las prioridades." << endl;
+	}
+	else {
+		for (int i = 0; i < ANIOS; i++) {
+			for (int j = 0; j < MAX_TIPOS; j++){
+				archivo >> prioridad[i][j];
+			}
+		}
+		carga = true;
+	}
+	archivo.close();
+
+	return carga;
+}
+
+bool cargarTareas(tListaTareas& lista, tPrioridades& prioridades, ifstream& archivo) {
+	bool carga = false;
+	
+	if (!archivo.fail()) {
+		archivo >> lista.tarea[lista.cont].codigo;
+		archivo.ignore();
+		getline(archivo, lista.tarea[lista.cont].descripcion);
+		lista.tarea[lista.cont].tiempo = calcularTiempo(lista, prioridades);
+		carga = true;
+	}
+	
+	return carga;
+}
+
+int calcularTiempo(tListaTareas& lista, tPrioridades& prioridades) {
+	int tiempo = 0;
+
+	for (int i = 0; i < ANIOS; i++){
+		for (int j = 0; j < MAX_TIPOS; j++){
+			tiempo += prioridades[i][j];
+		}
+	}
+	tiempo /= (ANIOS*MAX_TIPOS);
+	tiempo *= 20;
+
+	floor(tiempo);
+
+	return tiempo;
+}
+
+void mostrarTareas(tListaTareas& lista) {
+	for (int i = 0; i < lista.cont; i++){
+		cout << right << setw(2) << lista.tarea[i].codigo
+			<< setw(40) << lista.tarea[i].descripcion
+			<< setw(5) << lista.tarea[i].tiempo << endl;
+	}
+}

Exámenes Resueltos (Segundo Semestre)/Junio2018CEG/ListaTareas.h

@@ -0,0 +1,34 @@
+#ifndef H_LISTATAREAS_H
+#define H_LISTATAREAS_H
+
+#include <iostream>
+#include <string>
+#include <fstream>
+#include <iomanip>
+
+//Constantes:
+const int MAX_TAREAS = 15;
+const int MAX_TIPOS = 7;
+const int ANIOS = 5;
+
+//Tipos:
+typedef int tPrioridades[ANIOS][MAX_TIPOS];
+
+typedef struct tTarea {
+	int codigo;
+	std::string descripcion;
+	int tiempo;
+};
+
+typedef struct tListaTareas {
+	tTarea tarea[MAX_TAREAS];
+	int cont;
+};
+
+//Funciones:
+bool cargarPrioridades(tPrioridades& prioridad);
+bool cargarTareas(tListaTareas& lista, tPrioridades&, std::ifstream&);
+int calcularTiempo(tListaTareas& lista, tPrioridades&);
+void mostrarTareas(tListaTareas& lista);
+
+#endif // !H_LISTATAREAS_H

Exámenes Resueltos (Segundo Semestre)/Junio2018CEG/checkML.h

@@ -0,0 +1,9 @@
+#ifdef _DEBUG
+#define _CRTDBG_MAP_ALLOC
+#include <stdlib.h>
+#include <crtdbg.h>
+#ifndef DBG_NEW
+#define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )
+#define new DBG_NEW
+#endif
+#endif

Exámenes Resueltos (Segundo Semestre)/Junio2018CEG/contratos.txt

@@ -0,0 +1,23 @@
+3
+Sanchez Gomez, Juan
+12345678A
+1700
+2
+1
+Docencia en Ingenieria del Software
+7
+Publicacion de articulos y conferencias
+Martin Vazquez, Alberto
+87654321A
+1600
+1
+7
+Publicacion de articulos y conferencias
+Gonzalez Fernandez, Patricia
+32323232B
+1700
+2
+2
+Docencia en Ingenieria de Computadores
+7
+Publicacion de articulos y conferencias

Exámenes Resueltos (Segundo Semestre)/Junio2018CEG/main.cpp

@@ -0,0 +1,94 @@
+//Examen Junio 2018 - FP
+//Grupos C, E y G.
+//Fernando Méndez Torrubiano
+
+#include "Departamentos.h"
+#include "checkML.h"
+using namespace std;
+
+int menu();
+
+int main() {
+	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); //Muestra fugas de memoria.
+	system("chcp 1252"); //Castellano.
+	system("cls");
+
+	tDepartamento dpto;
+	tListaContratos lista;
+	tPrioridades prioridades;
+	tEmpleado empleado;
+	string id, nif;
+	int opcion, pos = -1;
+
+
+	if (cargarPrioridades(prioridades)) {
+		if (cargarContratos(lista, prioridades)) {
+			cout << "Identificador del departamento: ";
+			cin >> id;
+			cout << endl;
+			inicializar(dpto, id);
+			do {
+				opcion = menu();
+				switch (opcion){
+				case 1:
+					pos = seleccionarContratos(lista);
+					if (!insertarEmpleado(lista, dpto, pos)) {
+						cout << "Error al insertar el empleado." << endl;
+					}
+					break;
+				case 2:
+					cout << "NIF del emplieado: ";
+					cin >> nif;
+					cout << endl;
+					pos = buscarEmpleado(dpto, nif);
+					if (pos != -1) {
+						mostrarTareas(dpto.empleado[pos].puntero->lista);
+					}
+					else {
+						cout << "El empleado no está en el departamento." << endl;
+					}
+					cout << endl;
+					break;
+				case 3:
+					if (dpto.cont != 0) {
+						cout  << endl << "Los empleados del departamento '" << dpto.id  << "' son:" << endl;
+						mostrarDepartamentos(dpto);
+					}
+					else {
+						cout << "No hay empleados." << endl;
+					}
+					cout << endl;
+					break;
+				default:
+					break;
+				}
+			} while (opcion != 0);
+
+			liberar(lista);
+			liberar(dpto);	
+		}
+		else {
+			cout << "Error al cargar la lista de contratos." << endl;
+		}
+	}
+	else {
+		cout << "Error al cargar las prioridades." << endl;
+	}
+
+	return 0;
+}
+
+int menu() {
+	int opc = -1;
+
+	cout << "1.-Insertar empleado en nuevo dpto." << endl;
+	cout << "2.-Mostrar tareas de un empleado." << endl;
+	cout << "3.-Mostrar los empleados actuales de un dpto." << endl;
+	cout << "0.-SALIR." << endl;
+	do {
+		cout << "Introduzca una opc: ";
+		cin >> opc;
+	} while (opc < 0 || opc > 3);
+	
+	return opc;
+}

Exámenes Resueltos (Segundo Semestre)/Junio2018CEG/prioridades.txt

@@ -0,0 +1,5 @@
+5 5 4 3 1 2 4
+5 5 4 4 2 1 3
+4 5 3 3 3 2 3
+5 4 3 2 2 3 3
+4 5 4 3 3 2 4