Beispiel #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;
}
Beispiel #2
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;
}
Beispiel #3
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;
}