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.
This commit is contained in:
Fernando Méndez 2019-06-20 12:26:55 +02:00 committed by GitHub
parent 36df5ecef5
commit 07651a8047
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
58 changed files with 4923 additions and 0 deletions

View File

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

View File

@ -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

View File

@ -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

View File

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

View File

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

View File

@ -0,0 +1,5 @@
7
97
137
250
-1

View File

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

View File

@ -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

View File

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

View File

@ -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

View File

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

View File

@ -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

View File

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

View File

@ -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

View File

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

View File

@ -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

View File

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

View File

@ -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

View File

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

View File

@ -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

View File

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

View File

@ -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

View File

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

View File

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

View File

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

View File

@ -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

View File

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

View File

@ -0,0 +1,5 @@
ATM 5 Celta 0
DEP 3 BCN 1
GET2 4 GET1 4
RM 0 ZARA 9
VAL 1 Sevilla 1

View File

@ -0,0 +1,10 @@
CELTA 42
GET1 13
ATM 53
DEP 31
BCN 53
GET2 15
ZARA 16
Sevilla 13
VAL 15
RM 49

View File

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

View File

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

View File

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

View File

@ -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

Binary file not shown.

After

Width:  |  Height:  |  Size: 99 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 78 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 79 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 79 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 80 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 72 KiB

View File

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

View File

@ -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

View File

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

View File

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