예제 #1
0
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;
}
예제 #2
0
Lista<Atleta> JJOO::losMasFracasados(const Pais p) const {
//Crea una lista con los atletas que ganaron medallas
    int h=0;
    Lista<Atleta> rank;
    while(h<competenciasFinalizadasConOroEnPodio().longitud()){
        if (competenciasFinalizadasConOroEnPodio().iesimo (h).ranking().longitud()<3){
            rank.concatenar(competenciasFinalizadasConOroEnPodio().iesimo(h).ranking());
        }else{
            // 0, 1 y 2 en vez de 1,2,3
            rank.agregar(competenciasFinalizadasConOroEnPodio().iesimo (h).ranking().iesimo(0));
            rank.agregar(competenciasFinalizadasConOroEnPodio().iesimo (h).ranking().iesimo(1));
            rank.agregar(competenciasFinalizadasConOroEnPodio().iesimo (h).ranking().iesimo(2));
        }
        h++;
    }
//Este ciclo me da una lista de atletas del pais p que no ganaron ninguna medalla
    Lista<Atleta> atles;
    int n = 0;
    while (n < atletas().longitud()){
        Atleta competidor = atletas().iesimo(n);
        if ((competidor.nacionalidad()== p) && !rank.pertenece(competidor)) {
            atles.agregar(competidor);
        }
        n++;
    }
//Divido en dos casos, si la lista es vacia o si tiene al menos un elemento
    Lista<Atleta> atlesFracasados;
    if (atles.longitud()==0){
        atlesFracasados=atles;
    }
    else{
//Acá me fijo cual es el atleta que participó en mas competencias
        int k = 0, j=0;
        Atleta maxAp = atles.iesimo(k);
        Lista<Atleta> atlecomp= participantes();
        while (j < atles.longitud()){
            if (atlecomp.cantidadDeApariciones(maxAp)>atlecomp.cantidadDeApariciones(atles.iesimo(j))){
                    maxAp = atles.iesimo(j);
                }
            j++;
        }
//Acá creo la lista con todos los atletas que aparecen tantas veces como maxAp
        atlesFracasados.agregar(maxAp);
        int m=0;
        while (m < atles.longitud()){
            //No estabas viendo si el que tenia la misma cantidad de apariciones era el mismo
            if(   atlecomp.cantidadDeApariciones(maxAp) == atlecomp.cantidadDeApariciones(atles.iesimo(m)) &&
                !(atles.iesimo(m) == maxAp)) {
                atlesFracasados.agregar(atles.iesimo(m));
            }
            m++;
        }
    }
  return atlesFracasados;
}
예제 #3
0
void Competencia::cargar (std::istream& is){

    char dummy;
    string temp;

    //descarto hasta el primer "|"
    getline(is , temp , '|');

    //leo el nombre hasta el ultimo "|" descartandolo
    getline(is , _categoria.first , '|');

    //leo hata el primer "|" que rodea el sexo descartando
    getline(is , temp , '|');

    //leo el sexo hasta el ultimo "|"
    getline(is , temp , '|');
    _categoria.second = (temp == "Masculino"? Masculino : Femenino);

    //descarto hasta el primer "|" del estado
    getline(is , temp , '|');

    //descarto hasta el primer "|" del estado
    getline(is , temp , '|');
    _finalizada = (temp == "True"? true : false);

    //leo el "[" que indica el comienzo de la lista
    getline(is , temp , '[');

    Atleta atleta;

    // si tiene atletas los cargamos
    if( is.peek() != ']' ){

        //busco el "("
        is >> dummy;

        while( dummy != ']'){

            atleta = Atleta();
            atleta.cargar(is);
            _participantes.agregarAtras(atleta);

            //busco el ")"
            is >> dummy;

            //busco el "," o el "]"
            is >> dummy;

            if(dummy == ','){
                //busco el "(" que viene
                is >> dummy;
            }
        }
예제 #4
0
bool Competencia::leDioPositivo(const Atleta& a) const{
    int i = 0;
    while( _controlAntidoping.iesimo(i).first != a.ciaNumber() )
        i++;

    return _controlAntidoping.iesimo(i).second;
}
예제 #5
0
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;
}
예제 #6
0
Atleta atletaProdigio(const JJOO & j) {

    Atleta a = j.competenciasFinalizadasConOroEnPodio().cabeza().ranking().iesimo(0);
    int i= 1;

    // vale Pc: |competenciasConOroEnPodio(j)| > 0 && i == 1 && |competenciasConOroEnPodio(j)| >0
    // && a == cab ([campeon(c)| c <- competenciasConOroEnPodio(j)]);

    // Quiero ver: Pc -> I;
    // implica 1 <= i <= |competenciasConOroEnPodio|;
    // implica (∀c ∈ competenciasConOroEnPodio(j)[0..1)) añoNacimiento(a) >= añoNacimiento(campeon(c));
    // implica 1 <= i <= |competenciasConOroEnPodio| && esCampeon(a,j)
    // && (∀c ∈ competenciasConOroEnPodio(j)[0..i)) añoNacimiento(a) >= añoNacimiento(campeon(c));
    // Luego, Pc -> I;

    while (i<j.competenciasFinalizadasConOroEnPodio().longitud()) {
        // B: i < |competenciasConOroEnPodio(j)|
        // I: 1 <= i <= |competenciasConOroEnPodio(j)| && esCampeon(a,j)
        //&& (∀c ∈ competenciasConOroEnPodio(j)[0..i)) añoNacimiento(a) >= añoNacimiento(campeon(c));

        // variante V: |competenciasConOroEnPodio(j)| - i;
        // cota C: 0;

        // Estado E1;
        // vale I && B;

        if (a.anioNacimiento()
                <= j.competenciasFinalizadasConOroEnPodio().iesimo(i).ranking().iesimo(0).anioNacimiento() ) {
            // Estado IF1;
            // vale i == i@E1
            // && añoNacimiento(a@E1) <= añoNacimiento(campeon(competenciasConOroEnPodio(j)[i]));

            a = j.competenciasFinalizadasConOroEnPodio().iesimo(i).ranking().iesimo(0);
            // Estado G
            // vale i == i@E1
            // && añoNacimiento(a@E1) <= añoNacimiento(campeon(competenciasConOroEnPodio(j)[i]))
            // && a == campeon(competenciasConOroEnPodio(j)[i]);
        }

        // Estado E2;
        // vale G || H;
        // implica (añoNacimiento(a@E1) <= añoNacimiento(campeon(competenciasConOroEnPodio(j)[i]))
        // && a == campeon(competenciasConOroEnPodio(j)[i]))
        // || (añoNacimiento(a@E1) > añoNacimiento(campeon(competenciasConOroEnPodio(j)[i]))
        // && a == a@E1);
        // implica añoNacimiento(a) > añoNacimiento(campeon(competenciasConOroEnPodio(j)[i]));
        // implica esCampeon(a,j);
        // implica (∀c ∈ competenciasConOroEnPodio(j)[0..i]) añoNacimiento(a) >= añoNacimiento(campeon(c))

        i++;

        // Estado E3;
        // vale i == i@E2 + 1 && esCampeon(a,j)
        // && (∀c ∈ competenciasConOroEnPodio(j)[0..i@E2])
        // añoNacimiento(a) >= añoNacimiento(campeon(c));
        // implica 1 < i;
        // implica i == i@E2 + 1 < |competenciasConOroEnPodio(j)| + 1 <= |competenciasConOroEnPodio(j)|;
        // implica 1 <= i <= |competenciasConOroEnPodio(j)|;
        // implica i@E2 == i - 1;
        // implica (∀c ∈ competenciasConOroEnPodio(j)[0..i - 1])
        // añoNacimiento(a) >= añoNacimiento(campeon(c));
        // implica 1 <= i <= |competenciasConOroEnPodio(j)| && esCampeon(a)
        // && (∀c ∈ competenciasConOroEnPodio[0..i)) añoNacimiento(a) >= añoNacimiento(campeon(c));

        // Luego, E3 -> I;
        // (El invariante se mantiene)
        //
        // Quiero ver que la función variante disminuye
        // vale V = |competenciasConOroEnPodio(j)| - i@E3;
        // implica V = |competenciasConOroEnPodio(j)| - (i@E1 + 1);
        // implica V = |competenciasConOroEnPodio(j)| - i@E1 - 1 <
        // |competenciasConOroEnPodio(j)| - i@E1 == V@E1;
        // luego, V@E3 < V@E1.

        // Quiero Ver: (I && (V <= C)) -> ¬B.
        // Si V <= C, entonces vale I && (V <= C);
        // implica 1 <= i <= |competenciasConOroEnPodio(j)| && esCampeon(a,j)
        //&& ((∀c ∈ competenciasConOroEnPodio(j)[0..i)) añoNacimiento(a) >= añoNacimiento(campeon(c)))
        // && (|competenciasConOroEnPodio(j)| - i <= 0);

        // implica |competenciasConOroEnPodio(j)| <= i;
        // implica i == |competenciasConOroEnPodio(j)|;
        // implica ¬(i < |competenciasConOroEnPodio(j)|);
        //
        // Luego, (I && (V <= C)) -> ¬B.
    }

    // vale Qc: i == |competenciasConOroEnPodio(j)| && esCampeon(a,j)
    // && (∀c ∈ competenciasConOroEnPodio(j)) añoNacimiento(a) >= añoNacimiento(campeon(c));

    // Quiero Ver: (I && ¬B) -> Qc.
    // vale I && ¬B
    // implica 1 <= i <= |competenciasConOroEnPodio(j)| && esCampeon(a,j)
    //&& ((∀c ∈ competenciasConOroEnPodio(j)[0..i)) añoNacimiento(a) >= añoNacimiento(campeon(c)))
    // && ¬(i < |competenciasConOroEnPodio(j)|)

    // implica i >= |competenciasConOroEnPodio(j)|
    // implica i == |competenciasConOroEnPodio(j)|
    // implica (∀c ∈ competenciasConOroEnPodio(j)[0..|competenciasConOroEnPodio(j)|)) añoNacimiento(a) >=
    // añoNacimiento(campeon(c))
    // implica (∀c ∈ competenciasConOroEnPodio(j)) añoNacimiento(a) >= añoNacimiento(campeon(c))
    // implica i == |competenciasConOroEnPodio(j)| && esCampeon(a,j)
    // && (∀c ∈ competenciasConOroEnPodio(j)) añoNacimiento(a) >= añoNacimiento(campeon(c))
    // luego, (I && ¬B) -> Qc.

    return a;

    // vale      result == a
    // implica   esCampeon(result,j)
    // && (∀c ∈ competenciasConOroEnPodio(j)) añoNacimiento(result) >= añoNacimiento(campeon(c))
}
예제 #7
0
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;
            }
        }
예제 #8
0
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;
}
예제 #9
0
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;
}
예제 #10
0
void MenuAtleta()
{
    int maximaOpcion = 2;

    cout << "Creando atleta" << endl
            << "0. Volver al Menu Principal" << endl
            << "1. Crear atleta" << endl
            << "2. Cargar atleta" << endl;
    if (atletaCreado)
    {
        maximaOpcion = 10;
        cout << "3. Entrenar nuevo deporte" << endl
            << "4. Guardar atleta" << endl
            << "5. Mostrar" << endl
            << "6. Nombre" << endl
            << "7. Sexo" << endl
            << "8. Anio de nacimiento" << endl
            << "9. Nacionalidad" << endl
            << "10. CIA Number" << endl;
    }

    int opt = LeerOpcion(maximaOpcion);

    LimpiarPantalla();
    switch(opt)
    {
        case 0:
        {
                LimpiarPantalla();
                break;
        }
        case 1:
        {
                LimpiarPantalla();
                atleta = MenuCrearAtleta();
                atletaCreado = true;
                LimpiarPantalla();
                MenuAtleta();
                break;
        }
        case 2:
        {
            LimpiarPantalla();
            ifstream archivoEntrada;
            AbrirArchivoParaLeer(archivoEntrada);
            atleta.cargar(archivoEntrada);
            archivoEntrada.close();
            atletaCreado = true;
            LimpiarPantalla();
            MenuAtleta();
            break;
        }
        case 3:
        {
            int cantidad;
            //TODO: Chequear si la capacidad era un parametro más
            string nuevoDeporte;
            cout << "Indicar el deporte que desea entrenar y cuanto :";
            cin >> nuevoDeporte;
            cin >> cantidad;
            atleta.entrenarNuevoDeporte(nuevoDeporte, cantidad);
            LimpiarPantalla();
            MenuAtleta();
            break;
        }
        case 4:
        {
            LimpiarPantalla();
            ofstream archivoSalida;

            AbrirArchivoParaEscribir(archivoSalida);
            atleta.guardar(archivoSalida);
            archivoSalida.close();

            LimpiarPantalla();
            MenuAtleta();
            break;
        }
        case 5:
        {
            LimpiarPantalla();
            atleta.mostrar(cout);
            Pausar();
            LimpiarPantalla();
            MenuAtleta();
            break;
        }
        case 6:
        {
            cout << "Nombre: " << atleta.nombre() << endl;
            Pausar();
            LimpiarPantalla();
            MenuAtleta();
            break;
        }
        case 7:
        {
            cout << "Sexo: " << ((atleta.sexo()==Femenino)?  "Femenino" : "Masculino") << endl;
            Pausar();
            LimpiarPantalla();
            MenuAtleta();
            break;
        }
        case 8:
        {
            cout << "Anio de nacimiento: " << atleta.anioNacimiento() << endl;
            Pausar();
            LimpiarPantalla();
            MenuAtleta();
            break;
        }
        case 9:
        {
            cout << "Nacionalidad: " << atleta.nacionalidad() << endl;
            Pausar();
            LimpiarPantalla();
            MenuAtleta();
            break;
        }
        case 10:
        {
            cout << "CIA Number: " << atleta.ciaNumber() << endl;
            Pausar();
            LimpiarPantalla();
            MenuAtleta();
            break;
        }
    }
}