void JJOO::transcurrirDia() {
// Guardo acá el nuevo cronograma de la jornada actual.
Lista<Competencia> nuevoCronogramaJornadaActual;
// Recorro las competencias de la jornada actual.
int i = 0;
while(i < cronograma(jornadaActual()).longitud()) {
Competencia competencia = cronograma(jornadaActual()).iesimo(i);
// Si la competencia no estaba finalizada, la finalizo.
if (!competencia.finalizada()) {
competencia = finalizarCompetencia(competencia);
}
// Agrego competencia al nuevo cronograma.
nuevoCronogramaJornadaActual.agregarAtras(competencia);
i++;
}
// Reemplazo el cronograma de la jornada actual por el nuevo cronograma finalizado.
reemplazarCronogramaJornadaActual(nuevoCronogramaJornadaActual);
// Transcurro el día.
_jornadaActual++;
}
Lista<int> JJOO::generarRanking(const Competencia& competencia) const {
// Guardo acá el ranking construído.
Lista<int> ranking;
Lista<Atleta> participantesSinRankear = competencia.participantes();
// Rankeo todos los participantes hasta quedarme sin participantes para rakear.
while(participantesSinRankear.longitud() > 0) {
// Busco el participante con menos capacidad entre los que aún no fueron rankeados.
Atleta peorParticipante;
int i = 0;
while(i < participantesSinRankear.longitud()) {
Deporte deporte = competencia.categoria().first;
Atleta participante = participantesSinRankear.iesimo(i);
// En caso de ser el peor hasta el momento, me quedo con el participante i-ésimo.
if(i == 0 || participante.capacidad(deporte) < peorParticipante.capacidad(deporte)) {
peorParticipante = participante;
}
i++;
}
// Agrego el peor participante hallado al principio del ranking.
ranking.agregar(peorParticipante.ciaNumber());
// Lo elimino de la lista de participantes sin rankear.
participantesSinRankear.eliminarPosicion(participantesSinRankear.posicion(peorParticipante));
}
return ranking;
}
Lista<pair<int,bool> > JJOO::generarAntidoping(const Competencia& competencia) const {
Lista<pair<int,bool> > antidoping;
// Tomo al primer participante y lo agrego al control, con resultado falso.
if(competencia.participantes().longitud() > 0) {
antidoping.agregar(make_pair(competencia.participantes().cabeza().ciaNumber(), false));
}
return antidoping;
}
Competencia JJOO::finalizarCompetencia(const Competencia& competencia) const {
// Creo una copia de la competencia.
Competencia finalizada(competencia.categoria().first,
competencia.categoria().second,
competencia.participantes());
// Finalizo la competencia generando un ranking y un control antidoping.
finalizada.finalizar(generarRanking(competencia), generarAntidoping(competencia));
return finalizada;
}
Lista<Competencia> JJOO::competenciasFinalizadasConOroEnPodio() const {
Lista<Competencia> result;
int i = 0;
while (i < competencias().longitud()) {
Competencia actual = competencias().iesimo(i);
if (actual.finalizada() && actual.ranking().longitud() > 0) {
result.agregar(actual);
}
i++;
}
return result;
}
bool JJOO::ganoMedallasEseDia(Pais pais, int dia) const{
bool gano = false;
// Recorro el cronograma del día.
int i = 0;
while(i < cronograma(dia).longitud()) {
Competencia competencia = cronograma(dia).iesimo(i);
// Recorro el ranking de la competencia actual hasta el tercer puesto.
int j = 0;
while(j < competencia.ranking().longitud() && j < 3) {
// El valor de retorno es true sólo si el país ganó alguna medalla.
gano = gano || competencia.ranking().iesimo(j).nacionalidad() == pais;
j++;
}
i++;
}
return gano;
}
bool Competencia::operator==(const Competencia& c) const{
bool result = mismasAtletas(c.participantes() , participantes())
&& c.categoria() == categoria() && c.finalizada() == finalizada();
if(result && finalizada()){
result = c.ranking() == ranking()
&& mismasAtletas(c.lesTocoControlAntidoping(),lesTocoControlAntidoping());
if(result){
int i = 0;
while( i < c.lesTocoControlAntidoping().longitud() && result){
result = result && c.leDioPositivo(c.lesTocoControlAntidoping().iesimo(i))
== leDioPositivo(c.lesTocoControlAntidoping().iesimo(i));
i++;
}
}
}
return result;
}
Atleta JJOO::stevenBradbury() const {
// Guardo el atleta con menor capacidad, y la menor de sus
// capacidades de los deportes en los que salió campeón.
Atleta atletaMenosCapaz;
int capacidadMenosCapaz;
// Recorro la lista de competencias finalizadas con oro.
int i = 0;
while(i < competenciasFinalizadasConOroEnPodio().longitud()) {
// Guardo el campeón de la competencia actual y
// su capacidad en el deporte de la misma.
Competencia competencia = competenciasFinalizadasConOroEnPodio().iesimo(i);
Atleta campeon = competencia.ranking().cabeza();
int capacidadCampeon = campeon.capacidad(competencia.categoria().first);
// Si es la primera competencia que recorro, entonces tomo al campeón
// de la misma como el atleta menos capaz hasta el momento.
if(i == 0) {
atletaMenosCapaz = campeon;
capacidadMenosCapaz = capacidadCampeon;
}
// En caso contrario, si el campeón de esta competencia tiene una menor capacidad
// que el atleta menos capaz hasta el momento, lo tomo como el menso capaz.
else {
if(capacidadCampeon < capacidadMenosCapaz) {
atletaMenosCapaz = campeon;
capacidadMenosCapaz = capacidadCampeon;
}
}
i++;
}
return atletaMenosCapaz;
}
void JJOO::cargar (std::istream& is) {
char c;
//Saco J anio jornada [
is >> c >> _anio >> _jornadaActual >> c;
bool loop = true;
Lista<Atleta> nuevosAtletas;
if(is.peek() != ']') {
while(loop) {
//Saco (
is >> c;
Atleta atle;
atle.cargar(is);
nuevosAtletas.agregarAtras(atle);
//Saco )
is >> c;
if(is.peek() != ',') {
loop = false;
}
else {
//Saco la coma
is >> c;
}
}
}
_atletas = nuevosAtletas;
//Saco ] y [
is >> c >> c;
Lista<Lista<Competencia> > nuevasCompetenciasPorDia;
if(is.peek() != ']') {
loop = true;
while(loop) {
//Saco [
is >> c;
Lista<Competencia> nuevaCompetenciasEnElDia;
if(is.peek() != ']') {
Competencia compe;
bool secLoop = true;
while(secLoop) {
//Saco (
is >> c;
compe.cargar(is);
nuevaCompetenciasEnElDia.agregarAtras(compe);
//Saco )
is >> c;
if(is.peek() != ',') {
secLoop = false;
}
else {
//Saco la coma
is >> c;
}
}
}
//Saco ]
is >> c;
nuevasCompetenciasPorDia.agregarAtras(nuevaCompetenciasEnElDia);
if(is.peek() != ',') {
loop = false;
}
else {
//Saco la coma
is >> c;
}
}
bool JJOO::uyOrdenadoAsiHayUnPatron() const {
// Guardo acá la secuencia de mejores países.
Lista<Pais> mejoresPaises;
// Recorro los juegos día por día.
int dia = 1;
while(dia <= cantDias()) {
// Guardo acá la cantidad de oros por país.
Lista<pair<Pais, int> > oros;
// Recorro el las competencias de este día.
int i = 0;
while(i < cronograma(dia).longitud()) {
Competencia actual = cronograma(dia).iesimo(i);
// Si la competencia actual está finalizada y alguien se llevó el oro,
// voy a buscar la nacionalidad del medallista y voy a sumarle un oro a
// ese país en mi lista de oros por país. En caso contrario, ignoro
// esta competencia.
if(actual.finalizada() && actual.ranking().longitud() > 0) {
Pais pais = actual.ranking().iesimo(0).nacionalidad();
// Busco el país del medallista en mi lista de oros por país.
bool encontrado = false;
int j = 0;
while(j < oros.longitud() && !encontrado) {
// Si encontré el país del medallista en mi lista de oros por país,
// aumento en uno la cantidad de oros de ese país.
if(oros.iesimo(j).first == pais) {
pair<Pais, int> nuevaTupla = make_pair(oros.iesimo(j).first, oros.iesimo(j).second + 1);
oros.eliminarPosicion(j);
oros.agregarAtras(nuevaTupla);
encontrado = true;
}
j++;
}
// Si el país del medallista no estaba en la lista de oros por país,
// agrego ese país a la lista, con cantidad de oros uno.
if(!encontrado) {
oros.agregarAtras(make_pair(pais, 1));
}
}
i++;
}
// Si hubieron oros este día, busco al mejor país y lo agrego a mejoresPaises.
if(oros.longitud() > 0) {
// Guardo acá el mejor país hasta el momento (tupla país/oros.)
pair<Pais, int> mejorPais;
// Recorro la lista de oros por país.
i = 0;
while(i < oros.longitud()) {
// Si el país i-ésimo es el primero de la lista de oros, o si tiene más oros que el mejor país
// hasta el momento, o si tiene igual cantidad de oros pero es lexicográficamente menor,
// entonces convierto al país i-ésimo en el mejor país hasta el momento.
if( i == 0 ||
oros.iesimo(i).second > mejorPais.second ||
(oros.iesimo(i).second == mejorPais.second && oros.iesimo(i).first < mejorPais.first)) {
mejorPais = oros.iesimo(i);
}
i++;
}
// Finalmente, agrego al mejor país del día a la lista de mejores países.
mejoresPaises.agregarAtras(mejorPais.first);
}
dia++;
}
bool hayPatron = true;
// Busco patrón si y sólo si hay tres o más mejores países.
if(mejoresPaises.longitud() >= 3) {
// Recorro la lista de mejores países hasta el anteúltimo elemento.
int i = 0;
while(i < mejoresPaises.longitud() - 1) {
Pais actual = mejoresPaises.iesimo(i);
Pais siguiente = mejoresPaises.iesimo(i + 1);
// Recorro todos los países a la derecha del país actual
int j = i + 1;
while(j < mejoresPaises.longitud() - 1) {
// Si el país j-ésimo es el mismo que el actual, verifico que el patrón
// se cumpla (el elemento siguiente siempre debe ser el mismo.)
if(mejoresPaises.iesimo(j) == actual) {
hayPatron = hayPatron && (mejoresPaises.iesimo(j + 1) == siguiente);
}
j++;
}
i++;
}
}
return hayPatron;
}
void JJOO::liuSong(const Atleta& a, const Pais p) {
Atleta atletaNacionalizado(a.nombre(), a.sexo(), a.anioNacimiento(), p, a.ciaNumber());
int i = 0;
while(i<a.deportes().longitud()) {
atletaNacionalizado.entrenarNuevoDeporte(a.deportes().iesimo(i), a.capacidad(a.deportes().iesimo(i)));
i++;
}
//Saco el atleta y lo agrego nacionalizado en atletas;
_atletas.sacar(a);
_atletas.agregarAtras(atletaNacionalizado);
i=0;
int j = 0;
//Lista que va a reemplazar a la vieja lista de listas competencias
Lista<Lista<Competencia> > nuevaCompetenciasPorDia;
while(i<_competenciasPorDia.longitud()) {
//Lista de competencias que va a reemplazar a la anterior en ese dia
Lista<Competencia> nuevaCompetenciasEnDia;
j = 0;
while(j<_competenciasPorDia.iesimo(i).longitud()) {
Competencia viejaCompe = _competenciasPorDia.iesimo(i).iesimo(j);
//Me fijo si esa competencia tiene al atleta, si no, la dejo como estaba
if(viejaCompe.participantes().pertenece(a)) {
//Creo la nueva lista de participantes
Lista<Atleta> nuevosParticipantes = viejaCompe.participantes();
nuevosParticipantes.sacar(a);
nuevosParticipantes.agregarAtras(atletaNacionalizado);
//
//Guardo la categoria
Deporte dep = viejaCompe.categoria().first;
Sexo sex = viejaCompe.categoria().second;
//
//Creo lo que va a ser la nueva competencia con el atleta cambiado
//
Competencia nuevaCompe(dep, sex, nuevosParticipantes);
//Si esta finalizada, asigno el ranking y el doping
if(viejaCompe.finalizada()) {
int h = 0;
Lista<int> ranking;
Lista<pair<int, bool> > control;
while(h<viejaCompe.ranking().longitud()) {
ranking.agregarAtras(viejaCompe.ranking().iesimo(h).ciaNumber());
h++;
}
h = 0;
while(h<viejaCompe.lesTocoControlAntidoping().longitud()) {
bool leToco = viejaCompe.leDioPositivo(viejaCompe.lesTocoControlAntidoping().iesimo(h));
int suCiaNumber = viejaCompe.lesTocoControlAntidoping().iesimo(h).ciaNumber();
pair<int, bool> par = make_pair(suCiaNumber, leToco);
control.agregarAtras(par);
h++;
}
//Finalizo
nuevaCompe.finalizar(ranking, control);
}
//Agrego a lo que va a ser mi nueva lista de competencias en ese dia
nuevaCompetenciasEnDia.agregarAtras(nuevaCompe);
}
else {
nuevaCompetenciasEnDia.agregarAtras(viejaCompe);
}
j++;
}
i++;
nuevaCompetenciasPorDia.agregarAtras(nuevaCompetenciasEnDia);
}
_competenciasPorDia = nuevaCompetenciasPorDia;
}
int JJOO::boicotPorDisciplina(const Categoria categoria, const Pais pais) {
int sacados = 0;
// Guardo acá las nuevas competencias por día después de boicotear al país.
Lista<Lista<Competencia> > nuevaCompetenciasPorDia;
// Recorro todas las jornadas.
int i = 0;
while(i < _competenciasPorDia.longitud()) {
// Guardo acá las competencias finales de la jornada i-ésima.
Lista<Competencia> competenciasEnElDia;
// Recorro las competencias de la jornada i-ésima.
int j = 0;
while(j < _competenciasPorDia.iesimo(i).longitud()) {
Competencia competencia = _competenciasPorDia.iesimo(i).iesimo(j);
// Si es la competencia de la categoría buscada, la boicoteo.
if(competencia.categoria() == categoria) {
// Guardo acá el ciaNumber de los atletas boicoteados
Lista<int> ciaNumberDeSacados;
// Guardo acá los participantes que no boicoteé.
Lista<Atleta> participantes;
// Recorro la lista de participantes de la competencia actual.
int h = 0;
while(h < competencia.participantes().longitud()) {
Atleta participante = competencia.participantes().iesimo(h);
// Si el participante actual es de la nacionalidad a boicotear, lo dejo
// fuera de la nueva lista de participantes y guardo su ciaNumber.
if(participante.nacionalidad() == pais) {
ciaNumberDeSacados.agregarAtras(participante.ciaNumber());
sacados++;
}
// En caso contrario, lo agrego a la lista de nuevos participantes.
else {
participantes.agregarAtras(participante);
}
h++;
}
// Creo la nueva competencia con los participantes boicoteados.
Competencia competenciaBoicoteada(competencia.categoria().first,
competencia.categoria().second,
participantes);
// Finalizo la nueva competencia de ser necesario.
if(competencia.finalizada()) {
// Guardo acá el ranking de la nueva competencia.
Lista<int> ranking;
// Recorro el ranking de la competencia original.
int h = 0;
while(h < competencia.ranking().longitud()) {
int ciaNumberAtletaActual = competencia.ranking().iesimo(h).ciaNumber();
// Si el atleta actual no fue boicoteado, lo agrego al ranking en la posición que estaba.
if(!ciaNumberDeSacados.pertenece(ciaNumberAtletaActual)) {
ranking.agregarAtras(ciaNumberAtletaActual);
}
h++;
}
// Guardo acá el control antidoping de la nueva competencia.
Lista<pair<int, bool> > antidoping;
// Recorro el control antidoping de la competencia original.
h = 0;
while(h < competencia.lesTocoControlAntidoping().longitud()) {
Atleta controladoActual = competencia.lesTocoControlAntidoping().iesimo(h);
// Si el atleta controlado actual no fue boicoteado, lo agrego al control antidoping.
if(!ciaNumberDeSacados.pertenece(controladoActual.ciaNumber())) {
antidoping.agregarAtras(make_pair(controladoActual.ciaNumber(),
competencia.leDioPositivo(controladoActual)));
}
h++;
}
// Finalizo la competencia con el ranking y antidoping boicoteados.
competenciaBoicoteada.finalizar(ranking, antidoping);
}
// Agrego la competencia boicoteada a la nueva lista de competencias para la jornada i-ésima.
competenciasEnElDia.agregarAtras(competenciaBoicoteada);
}
// Si no es la que quiero boicotear, la dejo como está.
else {
competenciasEnElDia.agregarAtras(competencia);
}
j++;
}
// Agrego las nuevas competencias del día actual a la nueva lista de competencias por día.
nuevaCompetenciasPorDia.agregarAtras(competenciasEnElDia);
i++;
}
_competenciasPorDia = nuevaCompetenciasPorDia;
return sacados;
}
void MenuCompetencia()
{
int maximaOpcion = 2;
cout << "Creando competencia" << endl
<< "0. Volver al Menu Principal" << endl
<< "1. Crear competencia" << endl
<< "2. Cargar competencia" << endl;
if (competenciaCreada)
{
maximaOpcion = 15;
cout << "3. Finalizar competencia" << endl
<< "4. LinfordChristie" << endl
<< "5. ¿Ganan los mas capaces?" << endl
<< "6. Sancionar Tramposos" << endl
<< "7. ¿Le Dio positivo?" << endl
<< "8. Ranking" << endl
<< "9. Atletas que les toco control" << endl
<< "10. ¿Finalizada?" << endl
<< "11. Guardar" << endl
<< "12. Mostrar" << endl
<< "13. Participantes" << endl
<< "14. Categoria" << endl
<< "15. Clasifico tarde" << endl;
}
int opt = LeerOpcion(maximaOpcion);
LimpiarPantalla();
switch(opt)
{
case 0:
{
LimpiarPantalla();
break;
}
case 1:
{
LimpiarPantalla();
competencia = MenuCrearCompetencia();
competenciaCreada = true;
LimpiarPantalla();
MenuCompetencia();
break;
}
case 2:
{
LimpiarPantalla();
ifstream archivoEntrada;
AbrirArchivoParaLeer(archivoEntrada);
competencia.cargar(archivoEntrada);
archivoEntrada.close();
competenciaCreada = true;
LimpiarPantalla();
MenuCompetencia();
break;
}
case 3:
{
int id;
string doping;
Lista<int> posiciones = Lista<int>();
Lista< pair<int, bool> > resultados = Lista< pair<int, bool> >();
MostrarAtletas(competencia.participantes(), "Lista de participantes :");
cout << competencia.participantes() << endl;
cout << "Ingrese la lista de atletas segun id de la lista, seguido del resultado de doping del mismo."<< endl;
for (int i = 0; i < competencia.participantes().longitud(); i++)
{
cout << "Puesto numero " << i+1 << " : ";
cin >> id;
cin >> doping;
posiciones.agregarAtras(competencia.participantes().iesimo(id).ciaNumber());
resultados.agregar(pair<int, bool>(competencia.participantes().iesimo(id).ciaNumber(), doping == "s"));
}
competencia.finalizar(posiciones, resultados);
LimpiarPantalla();
MenuCompetencia();
break;
}
case 4:
{
int id;
string nombre;
LimpiarPantalla();
MostrarAtletas(competencia.participantes(), "Lista de participantes :");
cout << "Indique que atleta desea descalificar : " << endl;
cin >> id;
nombre = competencia.participantes().iesimo(id).nombre();
competencia.linfordChristie(competencia.participantes().iesimo(id).ciaNumber());
cout << "El atleta " << nombre <<" fue descalificado";
Pausar();
LimpiarPantalla();
MenuCompetencia();
break;
}
case 5:
{
LimpiarPantalla();
cout << "¿Ganan los más capaces? " << competencia.gananLosMasCapaces() << endl;
Pausar();
LimpiarPantalla();
break;
}
case 6:
{
cout << "Sancionando tramposos" << endl;
competencia.sancionarTramposos();
cout << "Tramposos sancionados" << endl;
Pausar();
LimpiarPantalla();
break;
}
case 7:
{
int id;
MostrarAtletas(competencia.participantes(), "Lista de participantes :");
cout << "Indique el id de atleta del que desea saber su resultado de doping :";
cin >> id;
cout << "Su resultado fue: " << competencia.leDioPositivo(competencia.participantes().iesimo(id)) << endl;
Pausar();
LimpiarPantalla();
break;
}
case 8:
{
MostrarAtletas(competencia.ranking(), "Ranking de la competencia :");
Pausar();
LimpiarPantalla();
break;
}
case 9:
{
MostrarAtletas(competencia.lesTocoControlAntidoping(), "Atletas a los que le toco control antidoping :");
Pausar();
LimpiarPantalla();
break;
}
case 10:
{
cout << "¿Está finalizada la competencia? " << competencia.finalizada() << endl;
Pausar();
LimpiarPantalla();
break;
}
case 11:
{
LimpiarPantalla();
ofstream archivoSalida;
AbrirArchivoParaEscribir(archivoSalida);
competencia.guardar(archivoSalida);
archivoSalida.close();
LimpiarPantalla();
MenuCompetencia();
break;
}
case 12:
{
LimpiarPantalla();
competencia.mostrar(cout);
Pausar();
LimpiarPantalla();
MenuCompetencia();
break;
}
case 13:
{
MostrarAtletas(competencia.participantes(), "Participantes de la competencia: ");
Pausar();
LimpiarPantalla();
MenuCompetencia();
break;
}
case 14:
{
cout << "Categoria: " << "[ Deporte: " << competencia.categoria().first << "| Sexo: " << competencia.categoria().second << "]" << endl;
Pausar();
LimpiarPantalla();
MenuCompetencia();
break;
}
case 15:
{
cout << "Ingresando nuevo participante" << endl;
Atleta nuevoAtleta = MenuCrearAtleta();
competencia.clasificoTarde(nuevoAtleta);
LimpiarPantalla();
MenuCompetencia();
break;
}
}
}
