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