void MainWindow::on_actionOpen_Disk_triggered()
{
QString disco = QFileDialog::getOpenFileName(this, "Seleccione un disco", "", "*.disk");
if(disco == "")
return;
QFileInfo file(disco);
QString name = file.baseName();
name.append(".disk");
Lista<string>* canciones = disk.openDisk(name.toStdString());
this->cant_bloques_previo = disk.super.used_blocks;
if(canciones != NULL)
{
for(int i = 0; i < canciones->getCantidad(); i++)
{
string cancion = canciones->obtenerValor(i);
ui->cmbSongs->addItem(cancion.c_str());
}
}
enableButtons();
ui->tableWidget->setRowCount(disk.super.cant_block / ui->tableWidget->columnCount());
loadTable();
}
/* Método calculaProbabilidade
* Irá calcular a probabilidade de um carro virar em uma pista, de acordo com um valor randômico
* gerado na classe Carro.
* @see retornaTamanho
* @see getProbabilidade
* @return i retornará um valor entre 0 e o tamanho da lista de pistas, que representará qual foi a pista
* que o carro escolheu.
* @return -1 Caso, ocorra algo que de erro, poderá ser identificado para posterior solução.
*/
int calculaProbabilidade(Carro* c) {
int *prob = probabilidades;
int numPistas = pistas->retornaTamanho();
int probabilidadeDoCarro = c->getProbabilidade();
int valorComp[numPistas];
valorComp[0] = prob[0];
for (int i = 1; i < numPistas; i++) {
valorComp[i] = valorComp[i - 1] + prob[i];
}
for (int i = 0; i < numPistas; i++) {
if (probabilidadeDoCarro <= valorComp[i]) {
return i;
}
}
return -1;
}
int _tmain(int argc, _TCHAR* argv[])
{
srand(time(NULL));
Lista l;
cout << "Crear una lista l con los valores, 2,3,6,7" << endl;
l.insertarFinal(new ElementoInt(2));
l.insertarFinal(new ElementoInt(3));
l.insertarFinal(new ElementoInt(6));
l.insertarFinal(new ElementoInt(7));
cout << "La lista l es: " << l << endl;
cout << endl;
cout << "Insertar el elemento 12, al inicio" << endl;
l.insertarInicio(new ElementoInt(12));
cout <<"La lista l es: "<< l << endl;
cout << endl;
cout << "Insertar el elemento 67, en la posicion 2" << endl;
l.insertar(new ElementoInt(67), 2);
cout << "La lista l es: " << l << endl;
cout << endl;
cout << "Remover el elemento del final" << endl;
l.removerFinal();
cout << "La lista l es: " << l << endl;
cout << endl;
cout << "Remover el elemento del inicio" << endl;
l.removerInicio();
cout << "La lista l es: " << l << endl;
cout << endl;
cout << "Remover el elemento de la posicion 2" << endl;
l.remover(2);
cout << "La lista l es: " << l << endl;
cout << endl;
system("pause");
return 0;
}
Conn_Server* ServerTCP::accetta(Address* client){ //L'indirizzo verrà compilato dalla funzione
Conn_Server* conn;
int id;
int len_addr;
len_addr = sizeof(struct sockaddr_in); //Per evitare errori per i valori non impostati bisogna impostare prima
id = accept(get_sock_id(), (struct sockaddr*) client->get_addr(),(socklen_t*) &len_addr); //Aspetta e accetta la connessione da un client scrivendo il suo indirizzo nei parametri client->get_addr
if(id<=0){
return NULL;
}
conn=new Conn_Server(id); //Crea la connessione in base all'id
lista_connessione->add_Nodo(conn);
return conn; //Ritorna la connessione per l'utilizzo separato dalla lista
}
/**
* Riempie ricorsivamente un sotto-albero in base all'elemento
* da inserire
* [FUNZIONE_PRIVATA]
*/
void private_riempiAlbero(Lista lista, int lunghezzaLista, Albero &t, nodoBin nodoRiferimento) {
tipoelem elemento;
posizione p;
nodoBin nuovoRiferimentoSx, nuovoRiferimentoDx;
Lista listaSx, listaDx;
int lSottolistaSx, lSottolistaDx;
// 1: calcola il mediano e lo scrive nel nodo di riferimento
p = mediano(lista,lista.primoLista(), lista.pos(lunghezzaLista));
lista.leggiLista(elemento, p);
t.scriviNodo(nodoRiferimento, elemento);
// :1
// 2: calcola la sottolista sinistra in base al mediano
listaSx = creaSottoLista(lista, lista.primoLista(), p);
lSottolistaSx = lunghezza(lista, lista.primoLista(), p);
// 2.1: controlla che abbia senso avviare una ricorsione
if ( lSottolistaSx > 0 ) {
t.insFiglioSx(nodoRiferimento);
nuovoRiferimentoSx = t.figlioSx(nodoRiferimento);
// 2.1.1 Se la lista ha 1 solo elemento, allora è una foglia
if ( lSottolistaSx == 1 ) {
listaSx.leggiLista(elemento, listaSx.primoLista());
t.scriviNodo(nuovoRiferimentoSx, elemento);
// :2.1.1
// 2.1.2 Se la lista ha piu di un elemento allora avvia la ricorsione
} else {
private_riempiAlbero(listaSx, lSottolistaSx, t, nuovoRiferimentoSx);
}
// :2.1.2
}
// :2.1
// 3: calcola la sottolista destra analogamente a quella sinistra
listaDx = creaSottoLista(lista, lista.succLista(p), salta(lista, lista.primoLista(), lunghezzaLista));
lSottolistaDx = lunghezzaLista / 2;
if ( lSottolistaDx > 0 ) {
t.insFiglioDx(nodoRiferimento);
nuovoRiferimentoDx = t.figlioDx(nodoRiferimento);
if ( lSottolistaDx == 1 ) {
listaDx.leggiLista(elemento, listaDx.primoLista());
t.scriviNodo(nuovoRiferimentoDx, elemento);
} else {
private_riempiAlbero(listaDx, lSottolistaDx, t, nuovoRiferimentoDx );
}
}
// :3
return;
}
/* Método passaCarro.
* Este método será responsável por fazer um carro passar pelo semáforo, adicionando-o em outra fila (outra pista) e
* removendo o mesmo da fila atual.
* @see FilaEnc::primeiro
* @see calculaProbabilidade
* @see estaCheia
* @see removeCarro
* @see adicionaCarro
* @exception ExcecaoSinalVermelho Se o sinal estiver vermelho o carro não poderá passar para outra pista.
* @return proxima Retornará qual será a próxima pista em que o carro estará.
*/
Pista* passaCarro() {
Carro* c = pistaLocal->primeiro();
int pistaEscolhida = calculaProbabilidade(c);
Pista* proxima = pistas->mostra(pistaEscolhida);
if(isAberto()) {
if (!proxima->estaCheia(c)) {
pistaLocal->removeCarro();
proxima->adicionaCarro(c);
return proxima;
} else {
proxima = pistaLocal;
}
} else {
throw ExcecaoSinalVermelho;
}
return proxima;
}
int main()
{
Lista l;
l.agregar(new Perro(5,"hola"));
l.agregar(new Perro(5,"adios"));
l.agregar(new Perro(8,"valemadre"));
l.insertar(new Lora(4,"blu"),9);
cout<<l.buscar("adios")->edad<<endl;
return 0;
}
int main()
{
int iPuntuacion = 0, iNumCorte = 0;
string Entrada;
Lista Jugadores;
while( cin >> Entrada >> iPuntuacion ) {
if( Entrada == "corte" ) {
iNumCorte++;
for( Lista::iterator it = Jugadores.begin(); it != Jugadores.end(); it++ ) {
if( it->second.first < iPuntuacion && it->second.second == 0 ) {
it->second.second = iNumCorte;
}
}
} else {
if( iNumCorte == 0 ) {
Jugadores[Entrada].first += iPuntuacion;
} else {
if( Jugadores.find( Entrada ) == Jugadores.end() ) {
cout << Entrada << "?" << endl;
} else {
if( Jugadores[Entrada].second != 0 ) {
cout << Entrada << " OUT" << endl;
} else {
Jugadores[Entrada].first += iPuntuacion;
}
}
}
}
}
vector<Pareja> Ordenar;
for( Lista::iterator it = Jugadores.begin(); it != Jugadores.end(); it++ ) {
Ordenar.push_back( Pareja(it->second.first, it->first) );
}
sort( Ordenar.begin(), Ordenar.end(), Comparar );
for( int i = 0; i < int(Ordenar.size()); i++ ) {
if( Jugadores[Ordenar[i].second].second == 0 )
cout << "** " << Ordenar[i].second << " " << Ordenar[i].first << endl;
else
cout << "C" << Jugadores[Ordenar[i].second].second << " " << Ordenar[i].second << " " << Ordenar[i].first << endl;
}
return 0;
}
ConnessioneServer* ServerTCP::accetta() {
Address addr;
ConnessioneServer* conn;
struct sockaddr_in sAddr = addr.get_sockaddr();
socklen_t len = sizeof(struct sockaddr);
int sock = accept(_sockId, (struct sockaddr*)&sAddr, (socklen_t*)&len);
#ifdef DEBUG
printf("%s\n", strerror(errno));
#endif
if(sock < 0)
return NULL;
addr.set_sockaddr(sAddr);
conn = new ConnessioneServer(sock, addr);
connessioni->add(conn);
return conn;
}
PertCpm<Actividade*, int>
Projecto::load_pert()
{
PertCpm<Actividade*, int> p;
Lista<Actividade*> l = this->l_actividades;
Actividade *a;
Lista<Actividade*> lp = this->l_actividades;
Actividade *b;
int x = 1;
int y = 1;
while( ! l.vazia() ){
l.remove( x, a);
lp = a->getPrecedencias();
while( ! lp.vazia() ){
lp.remove(y, b);
p.juntar_ramo(y, b , a);
}
}
return p;
}
int main(){
srand(time(NULL));
int ilosc;
//wczytywanie od uzytkownika informacji
//o ilosci elementow dodanych do listy
printf("Podaj ilosc elementow: ");
scanf("%d",&ilosc);
Lista zadanie;
//dodawanie elementow do listy
for(int i=0; i<ilosc; i++){
if(!zadanie.AddSort(rand()%200+1)){
printf("Klucz o podanym indexie juz istnieje!\n");
}
}
zadanie.Wyswietl(true);
int szuk;
printf("Szukaj elementu: ");
scanf("%d",&szuk);
pole*sz=zadanie.Szukaj(szuk);
//jezeli znalazlo
if(sz){
printf("Znalazlem klucz: %d\n",sz->klucz);
}
//jesli nie znalazlo
else printf("Nie znalazlem podanego klucza!\n");
int usun;
printf("Usun element: ");
scanf("%d",&usun);
if(zadanie.Usun(usun)){
printf("Usunalem klucz: %d\n",usun);
}
//jesli nie znalazlo
else printf("Nie znalazlem podanego klucza!\n");
zadanie.Wyswietl(false);
return 0;
}
void Lista::quickSort(Lista list, int left, int right)
{
int i=left;
int j=right;
int mid=(left+right)/2;
int x=list.getName(mid);
while(i<=j)
{
while(list.getName(i)<x) i++;
while(list.getName(j)>x) j--;
if (i<=j)
{
swap(list.getName(i), list.getName(j));
swap(list.getNext(i), list.getNext(j));
i++;
j--;
}
}
if(left<j) quickSort(list, left, j);
if(right>i) quickSort(list, i, right);
}
bool Competencia::gananLosMasCapaces() const{
Deporte d = categoria().first;
Lista<Atleta> rank = ranking();
int i = 0;
bool res;
while (i<_ranking.longitud()){
if (rank.longitud()<=1){
res = true;
i = _ranking.longitud();
} else {
if(rank.iesimo(0).capacidad(d) >= rank.iesimo(1).capacidad(d)){
rank.sacar(rank.iesimo(0));
} else {
res = false;
i = _ranking.longitud();
}
}
}
return res;
}
void caminos_simples(const Grafo<C> & grafo, int origen, int destino,
bool visitado[], Lista<Lista<int> > & caminos, Lista<int> & camino_parcial)
{
visitado[origen] = true;
camino_parcial.agregarFinal(origen);
if (origen == destino) {
caminos.agregarFinal(camino_parcial);
camino_parcial.eliminarFinal();
visitado[origen] = false;
return;
}
Lista<typename Grafo<C>::Arco> adyacentes;
grafo.devolverAdyacentes(origen, adyacentes);
typename Lista<typename Grafo<C>::Arco>::Iterador ady = adyacentes.devolverIterador();
while (!ady.llegoAlFinal()) {
int v = ady.elementoActual().devolverAdyacente();
if (!visitado[v])
caminos_simples(grafo, v, destino, visitado, caminos, camino_parcial);
ady.avanzar();
}
camino_parcial.eliminarFinal();
visitado[origen] = false;
}
LinkLinkIt::ItAcceso::ItAcceso(Lista<Acceso> &ac)
{
_itLista = ac.CrearIt();
}
Nodo* Iterator::move_first(){
if(_lista){
_current=_lista->get_first();
}
return get_current();
}
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;
}
}
Lista<pair<Pais, Lista<int> > > JJOO::medallero() const {
Lista<Pais> paises = this->paises();
Lista<pair<Pais, Lista<int> > > medallero;
// Recorro la lista de países.
int i = 0;
while(i < paises.longitud()) {
Pais pais = paises.iesimo(i);
int oros = 0;
int platas = 0;
int bronces = 0;
// Recorro los rankings de todas las competencias y acumulo las medallas del país actual.
int j = 0;
while(j < competencias().longitud()) {
Lista<Atleta> ranking = competencias().iesimo(j).ranking();
if(ranking.longitud() > 0 && ranking.iesimo(0).nacionalidad() == pais) oros++;
if(ranking.longitud() > 1 && ranking.iesimo(1).nacionalidad() == pais) platas++;
if(ranking.longitud() > 2 && ranking.iesimo(2).nacionalidad() == pais) bronces++;
j++;
}
// Si el país ganó alguna medalla, agrego al medallero la tupla país/medallas.
if(oros + platas + bronces > 0) {
Lista<int> medallas;
medallas.agregarAtras(oros);
medallas.agregarAtras(platas);
medallas.agregarAtras(bronces);
medallero.agregar(make_pair(pais, medallas));
}
i++;
}
// Devuelvo el medallero ordenado
return ordenarMedallero(medallero);
}
Lista<Pais> JJOO::sequiaOlimpica() const {
Lista<Pais> paises = this->paises();
// Guardo acá una lista de tuplas país/máxima cantidad de días que pasaron sin ganar medallas.
Lista<pair<Pais,int> > paisDiasSinGanar;
// Recorro todos los países.
int i = 0;
while (i < paises.longitud()) {
Pais pais = paises.iesimo(i);
// Armo una lista con las jornadas ganadoras de ese país.
Lista<int> jornadasGanadoras;
// Agrego un cero al principio de la lista para poder calcular
// las diferencias entre días (como en la especificación.)
jornadasGanadoras.agregar(0);
// Recorro las jornadas hasta la actual, excluyéndola.
int j = 1;
while (j < jornadaActual()){
// Si el país ganó alguna medalla en la jornada
// actual, agrego la jornada a la lista.
if(ganoMedallasEseDia(pais, j)) {
jornadasGanadoras.agregarAtras(j);
}
j++;
}
// Agrego la jornada actual al final de la lista, para poder calcular
// las diferencias entre días (otra vez, como en la especificación.)
jornadasGanadoras.agregarAtras(jornadaActual());
// Calculo la máxima diferencia entre días, y agrego
// la tupla país/diferencia de días a la lista.
paisDiasSinGanar.agregarAtras(make_pair(pais, maximaDistanciaEntreJornadas(jornadasGanadoras)));
i++;
}
// Busco la máxima cantidad de días que algún país pasó sin ganar medallas.
int maximosDiasSinGanar;
i = 0;
while(i < paisDiasSinGanar.longitud()) {
if(i == 0 || paisDiasSinGanar.iesimo(i).second > maximosDiasSinGanar) {
maximosDiasSinGanar = paisDiasSinGanar.iesimo(i).second;
}
i++;
}
// Me quedo con los países cuya mayor cantidad de días sin ganar medallas
// es mayor o igual que la del resto de los países.
Lista<Pais> secos;
i = 0;
while (i < paisDiasSinGanar.longitud()) {
if(paisDiasSinGanar.iesimo(i).second == maximosDiasSinGanar) {
secos.agregar(paisDiasSinGanar.iesimo(i).first);
}
i++;
}
return secos;
}
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;
}
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;
}
void Cine::cargar (std::istream& is) {
Nombre n;
Pelicula p;
Lista<pair<Pelicula,Sala> > ps ;
Lista<pair<Sala, int> > es ;
Lista <Ticket> tvsu;
int s;
int e;
int i;
Ticket t;
char c;
is >> c;
is >> c;
getline(is, nombre_,'|');
is >> c;//descarta el [
while (c!=']') {
is >> s;
salasSinUsar_.agregarAtras(s);
is >> c;//vale , o ]
}
is >> c;//descarta [
while (c!=']') {
is >> c;//descarta (
if (c==']'){
break;
}
is >> s;
is >> c;//descarta ,
is >> e;
es.agregarAtras(make_pair(s,e));
is >> c;//descarta )
is >> c;//vale , o ]
}
espectadores_ = es;
is >> c;//descarta [
while (c!=']') {
is >> c;//descarta (
if (c==']'){
break;
}
is >> s;
is >> c;//descarta ,
is >> i;
while (i !=0) {
ticketsVendidos_.agregar(Ticket(peliculaC(s),s,false));
i=i-1;
}
is >> c;//descarta )
is >> c;//vale , o ]
}
is >> c;//descarta [
while (c!=']') {
is >> c;//descarta (
if (c==']'){
break;
}
is >> s;
is >> c;//descarta ,
is >> c;//descarta (
p.cargar(is);
ps.agregarAtras(make_pair(p,s));
is >> c;//descarta )
is >> c;//descarta )
is >> c;//vale , o ]
}
peliculas_ =ps;
is >> c;
}
void Reportes::reportePorDistrito(int idDistrito, bool guardaEncriptado, string claveEncriptado)
{
ABMConteo *abmConteo = new ABMConteo();
ABMEleccion* abmEleccion = new ABMEleccion();
ABMCargo* abmCargo = new ABMCargo();
ABMDistrito* abmDistrito = new ABMDistrito();
std::stringstream out;
vector<Conteo> resultados = abmConteo->GetConteoByDistrito(idDistrito);
if(resultados.size() == 0){
out << "No se encontraron resultados." << endl;
return;
}
//Primero ordeno por fecha de eleccion
resultados = Reportes::OrderByFecha(resultados);
//Agrupo por fecha de eleccion
vector< vector<Conteo> > resAgrupados;
vector<Conteo> cs;
cs.push_back(resultados[0]);
resAgrupados.push_back(cs);
int idEleccionActual = resultados[0].GetIdEleccion();
//Tengo que agrupar por eleccion
for(int i = 1; i < resultados.size(); i++){
Conteo conteo = resultados[i];
if(conteo.GetIdEleccion() == idEleccionActual){
resAgrupados[resAgrupados.size() - 1].push_back(conteo);
}
else{ //Nuevo grupo de eleccion
vector<Conteo> cs;
cs.push_back(conteo);
resAgrupados.push_back(cs);
idEleccionActual = conteo.GetIdEleccion();
}
}
for(int i = 0; i < resAgrupados.size(); i++){
vector<Conteo> aux = Reportes::OrderByCantidadVotos(resAgrupados[i]);
resAgrupados[i] = aux;
}
out << endl << endl << endl;
ABMLista* abmLista = new ABMLista();
for(int i = 0; i < resAgrupados.size(); i++){
vector<Conteo> cs = resAgrupados[i];
if(resAgrupados.size() > 0){
Conteo conteo = cs[0];
Eleccion* e = abmEleccion->GetEleccion(conteo.GetIdEleccion());
string cargo = abmCargo->GetCargo(e->GetIdCargo())->GetNombre();
Fecha fecha = e->GetDate().getStrFecha();
out << "Eleccion: (" << fecha.getFriendlyStr() << " - " << cargo << ")" << endl;
for(int j = 0; j < cs.size(); j++){
Conteo res = cs[j];
Lista* lista = abmLista->GetLista(res.GetIdLista());
out << " Lista: " << lista->GetNombre() << " tiene " << res.GetCountVotos() << " votos." << endl;
}
}
}
if (guardaEncriptado)
{
string fileName = ConfigurationMananger::getInstance()->getReportFileDirectory().append("ReportexDistrito");
fileName.append(Helper::IntToString(Identities::GetNextNroReporteXDistrito())).append(".ecr");
string reporteEncriptado = Vigenere::encriptar(claveEncriptado, out.str());
ofstream file;
file.open(fileName.c_str(), ios::app);
file.write(reporteEncriptado.c_str(), reporteEncriptado.size());
file.close();
cout << "Reporte encriptado correctamente" << endl;
}
else{
cout << out.str();
}
delete abmConteo;
delete abmEleccion;
delete abmCargo;
delete abmDistrito;
delete abmLista;
}
int main()
{
Arreglo arr;
Lista lista;
int op;
do{
cout << "\nIngrese la opcion : "<<endl;
cout << "1. Insertar nuevo empleado "<<endl;
cout << "2. Inicio "<<endl;
cout << "3. Final "<<endl;
cout << "4. Siguiente "<<endl;
cout << "5. Recuperar "<<endl;
cout << "6. Eliminar "<<endl;
cout << "7. Mover "<<endl;
cout << "8. Imprimir empleados "<<endl;
cin>>op;
switch(op)
{
case 1:
{
int id;
string nombre;
int pos;
cout << "\nIngrese la posicion donde insertar ";
cin>>pos;
cout << "\nIngrese el codigo de empleado ";
cin>>id;
cout << "Ingrese el nombre ";
cin>>nombre;
Nodo *a = new Nodo(id,nombre) ;
if(lista.insertar(pos,a))
cout << "\nInsertado exitosamente "<<endl;
else
cout << "\nNo se pudo insertar "<<endl;
}
break;
case 2:
{
Nodo* b = lista.ini();
if(b!=NULL)
{
cout<<"\nEl inicio es: ";
cout<<"-----"<<b->emp->id<<" ";
cout<<b->emp->nombre<<endl;
}
else
cout<<"\nArreglo vacio"<<endl;
}
break;
case 3:
{
Nodo* c=lista.fin();
if(c!=NULL)
{
cout<<"\nEl fin es: ";
cout<<"-----"<<c->emp->id<<" ";
cout<<c->emp->nombre<<endl;
}
else
cout<<"\nArreglo vacio"<<endl;
}
break;
case 4:
{
int pos;
cout << "\nIngrese la posicion para conocer su siguiente ";
cin>>pos;
Nodo* c=lista.siguiente(pos);
if(c!=NULL)
{
cout<<"\nEl siguiente de la posicion "<<pos<<" es: ";
cout<<"-----"<<c->emp->id<<" ";
cout<<c->emp->nombre<<endl;
}
else
cout<<"\nEsta posicion no tiene siguiente"<<endl;
}
break;
case 5:
{
int p1;
cout<<"\nIngrese la posicion a buscar: ";
cin>>p1;
Nodo * d= lista.recuperar(p1);
if(d!=NULL)
{
cout<<"-----"<<d->emp->id<<" ";
cout<<d->emp->nombre<<endl;
}
else
cout<<"No se encuentra, revise parametros"<<endl;
}
break;
case 6:
{
int p;
cout<<"\nIngrese la posicion a eliminar: ";
cin>>p;
if(lista.eliminar(p))
cout<<"\nEliminado exitosamente"<<endl;
else
cout<<"\nNo se pudo eliminar, revise los parametros "<<endl;
}
break;
case 7:
{
int from,to;
cout<<"\nIngrese la posicion de procedencia: ";
cin>>from;
cout<<"\nIngrese la posicion de destino: ";
cin>>to;
lista.mover(from,to);
}
break;
case 8:
{
cout<<"\nListando empleados "<<endl;
lista.imprimir();
}
break;
}
}while ( op >= 1 && op<=8 );
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
cout << "-------Probando con Int-------" << endl;
Lista<int> numInt;
for (int i = 0; i < 5; ++i) {
numInt.insertarAlFrente(i);
numInt.imprimir();
}
numInt.eliminarDelMedio(2);
numInt.imprimir();
cout << "-------Iterador hacia Adelante-------" << endl;
Iterador<int> it = numInt.begin();
while (it != numInt.end()) {
cout << *it << endl;
++it;
}
cout << "-------Iterador Inverso-------" << endl;
IteradorInverso<int> it2 = numInt.rbegin();
while (it2 != numInt.rend()) {
cout << *it2 << endl;
++it2;
}
cout << "-------Probando con Double-------" << endl;
Lista<double> numDou;
for (int i = 0; i < 5; ++i) {
numDou.insertarAlFrente(i/2.22);
numDou.imprimir();
}
numDou.eliminarDelMedio(2);
numDou.imprimir();
cout << "-------Iterador hacia Adelante-------" << endl;
Iterador<double> it3 = numDou.begin();
while (it3 != numDou.end()) {
cout << *it3 << endl;
++it3;
}
cout << "-------Iterador Inverso-------" << endl;
IteradorInverso<double> it4 = numDou.rbegin();
while (it4 != numDou.rend()) {
cout << *it4 << endl;
++it4;
}
cout << "-------Probando con Char-------" << endl;
Lista<char> numChar;
for (char i = 'a'; i < 'a' + 5; ++i) {
numChar.insertarAlFrente(i);
numChar.imprimir();
}
numChar.eliminarDelMedio(2);
numChar.imprimir();
cout << "-------Iterador hacia Adelante-------" << endl;
Iterador<char> it5 = numChar.begin();
while (it5 != numChar.end()) {
cout << *it5 << endl;
++it5;
}
cout << "-------Iterador Inverso-------" << endl;
IteradorInverso<char> it6 = numChar.rbegin();
while (it6 != numChar.rend()) {
cout << *it6 << endl;
++it6;
}
cout << "-------Probando con Clase Persona-------" << endl;
Lista<Persona> numPersona;
Persona p1("Arbol", "1");
Persona p2("Hoja", "2");
Persona p3("Zeta", "3");
numPersona.insertarAlFinal(p2);
numPersona.imprimir();
numPersona.insertarAlFinal(p1);
numPersona.imprimir();
numPersona.insertarAlFinal(p3);
numPersona.imprimir();
numPersona.insertarAlFinal(p3);
numPersona.imprimir();
numPersona.insertarAlFinal(p2);
numPersona.imprimir();
numPersona.insertarAlFinal(p1);
numPersona.imprimir();
numChar.eliminarDelMedio(2);
numChar.imprimir();
cout << "-------Iterador hacia Adelante-------" << endl;
Iterador<Persona> it7 = numPersona.begin();
while (it7 != numPersona.end()) {
cout << *it7 << endl;
++it7;
}
cout << "-------Iterador Inverso-------" << endl;
IteradorInverso<Persona> it8 = numPersona.rbegin();
while (it8 != numPersona.rend()) {
cout << *it8 << endl;
++it8;
}
system("pause");
return 0;
}
LinkLinkIt::itLinks::itLinks(Lista<DatosLink> &ldl){
_itLista = ldl.CrearIt();
}
Lista<pair<Pais,Lista<int> > > JJOO::ordenarMedallero(const Lista<pair<Pais,Lista<int> > > & medallero) const {
// Guardo acá mi copia ordenada del medallero.
Lista<pair<Pais, Lista<int> > > ordenado;
// Recorro el medallero.
int i = 0;
while(i < medallero.longitud()) {
// Obtengo la tupla país/medallas actual y las medallas (para más legibilidad.)
pair<Pais, Lista<int> > tuplaActual = medallero.iesimo(i);
int oros = tuplaActual.second.iesimo(0);
int platas = tuplaActual.second.iesimo(1);
int bronces = tuplaActual.second.iesimo(2);
// Guardo acá una copia de las tuplas país/medallas que ya ordené, junto con
// la tupla país/medallas actual en la posición correcta.
Lista<pair<Pais, Lista<int> > > nuevoOrdenado;
bool agregado = false;
// Recorro las tuplas país/medallas que ya ordené.
int j = 0;
while(j < ordenado.longitud()) {
int orosOtro = ordenado.iesimo(j).second.iesimo(0);
int platasOtro = ordenado.iesimo(j).second.iesimo(1);
int broncesOtro = ordenado.iesimo(j).second.iesimo(2);
// Ubico a la tupla país/medallas actual en la posición correcta dentro de la lista ordenada.
if( !agregado &&
((oros > orosOtro) ||
(oros == orosOtro && platas > platasOtro) ||
(oros == orosOtro && platas == platasOtro && bronces >= broncesOtro))) {
nuevoOrdenado.agregarAtras(tuplaActual);
agregado = true;
}
// Dejo la tupla que ya había ordenado en la posición que le corresponde.
nuevoOrdenado.agregarAtras(ordenado.iesimo(j));
j++;
}
// Si luego de recorrer las tuplas país/medallas ya ordenadas resulta que todavía no agregué
// la tupla país/medallas actual, es porque la tupla actual es la que menos medallas tiene, y
// por lo tanto su posición es al final de la lista.
if(!agregado) nuevoOrdenado.agregarAtras(tuplaActual);
// Finalmente, reemplazo el medallero ordenado actual por mi nuevo medallero ordenado, que
// incluye a la tupla país/medallas actual.
ordenado = nuevoOrdenado;
i++;
}
return ordenado;
}
LinkLinkIt::itPunLinks::itPunLinks(Lista<DatosLink*> &ldl, Fecha& f){
_itLista = ldl.CrearIt();
_fecha = f;
}
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;
}
