void map() {
lista* l = lista_crear();
jugador* j1 = crear_jugador("Ginobili", "Argentina", 5, 198);
jugador* j2 = crear_jugador("Scola", "Argentina", 6, 198);
jugador* j3 = crear_jugador("Prigioni", "Argentina", 7, 198);
jugador* j4 = crear_jugador("Ginobili", "Argentina", 9, 199);
jugador* j5 = crear_jugador("Ginobili", "Argentina", 10, 199);
insertar_ordenado(l, (void*)j1, (tipo_funcion_cmp)&menor_jugador);
lista* lmap=mapear(l, (tipo_funcion_mapear)&i);
assert(((jugador*)lmap->primero->datos)->altura==j1->altura);
lista_imprimir(lmap, "hola.out",(tipo_funcion_imprimir)&imprimir_jugador);
lista_borrar(lmap,(tipo_funcion_borrar)&borrar_jugador);
insertar_ordenado(l, (void*)j2, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j3, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j4, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j5, (tipo_funcion_cmp)&menor_jugador);
lista* lmap2=mapear(l, (tipo_funcion_mapear)&normalizar_jugador);
lista_imprimir(lmap2, "hola.out",(tipo_funcion_imprimir)&imprimir_jugador);
jugador* n1 = normalizar_jugador(j1);
assert(((jugador*)lmap2->primero->datos)->altura==n1->altura);
borrar_jugador(n1);
lista_borrar(lmap2,(tipo_funcion_borrar)&borrar_jugador);
lista_borrar(l,(tipo_funcion_borrar)&borrar_jugador);
}
void ordenar() {
lista* l = lista_crear();
jugador* j1 = crear_jugador("Ginobili", "Argentina", 5, 198);
nodo* n1 = nodo_crear(j1);
jugador* j2 = crear_jugador("Scola", "Argentina", 6, 198);
nodo* n2 = nodo_crear(j2);
jugador* j3 = crear_jugador("Prigioni", "Argentina", 7, 198);
nodo* n3 = nodo_crear(j3);
jugador* j4 = crear_jugador("Ginobili", "Argentina", 9, 199);
nodo* n4 = nodo_crear(j4);
jugador* j5 = crear_jugador("Ginobili", "Argentina", 10, 199);
nodo* n5 = nodo_crear(j5);
insertar_ultimo(l, n1);
lista* lord=ordenar_lista_jugadores(l);
lista_imprimir(lord, "hola.out",(tipo_funcion_imprimir)&imprimir_jugador);
assert(((jugador*)lord->primero->datos)->altura==j1->altura);
lista_borrar(lord,(tipo_funcion_borrar)&borrar_jugador);
insertar_ultimo(l, n2);
insertar_ultimo(l, n3);
insertar_ultimo(l, n4);
insertar_ultimo(l, n5);
lista* lord2=ordenar_lista_jugadores(l);
assert(((jugador*)lord2->primero->datos)->altura==j1->altura);
lista_imprimir(lord2, "hola.out",(tipo_funcion_imprimir)&imprimir_jugador);
lista_borrar(lord2,(tipo_funcion_borrar)&borrar_jugador);
lista_borrar(l,(tipo_funcion_borrar)&borrar_jugador);
}
void generar() {
lista* l = lista_crear();
jugador* j1 = crear_jugador("Ginobili", "Argentina", 5, 198);
jugador* j2 = crear_jugador("Scola", "Transnistria", 6, 198);
jugador* j3 = crear_jugador("Prigioni", "Argentina", 7, 198);
jugador* j4 = crear_jugador("Ginobili", "Argentina", 9, 199);
jugador* j5 = crear_jugador("Ginobili", "Transnistria", 10, 199);
insertar_ordenado(l, (void*)j1, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j2, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j3, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j4, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j5, (tipo_funcion_cmp)&menor_jugador);
lista* gen=generar_selecciones(l);
lista_imprimir(gen, "hola.out",(tipo_funcion_imprimir)&imprimir_seleccion);
assert(((seleccion*)gen->primero->sig->datos)->alturaPromedio==6);
//Los dos Transnistrios son de 6 pies
assert(((jugador*)((seleccion*)gen->primero->datos)->jugadores->primero->datos)->altura==6);
//El primero de argentina es Gino (6 pies)
lista_borrar(gen,(tipo_funcion_borrar)&borrar_seleccion);
lista_borrar(l,(tipo_funcion_borrar)&borrar_jugador);
}
void filtrar() {
lista* l = lista_crear();
jugador* j1 = crear_jugador("Ginobili", "Argentina", 5, 198);
jugador* j2 = crear_jugador("Scola", "Antartida", 6, 198);
jugador* j3 = crear_jugador("Prigioni", "Argentina", 7, 198);
nodo* n3 = nodo_crear(j3);
jugador* j4 = crear_jugador("Ginobili", "Argentina", 9, 199);
jugador* j5 = crear_jugador("Ginobili", "Antartida", 10, 199);
insertar_ultimo(l, n3);
insertar_ordenado(l, (void*)j1, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j2, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j4, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j5, (tipo_funcion_cmp)&menor_jugador);
lista* lfil=filtrar_jugadores(l, (tipo_funcion_cmp)&menor_jugador,n3);
lista_imprimir(lfil, "hola.out",(tipo_funcion_imprimir)&imprimir_jugador);
assert(((jugador*)lfil->primero->sig->sig->datos)->altura==j4->altura);
lista_borrar(lfil,(tipo_funcion_borrar)&borrar_jugador);
lista* lfil2=filtrar_jugadores(l, (tipo_funcion_cmp)&pais_jugador,n3);
lista_imprimir(lfil2, "hola.out",(tipo_funcion_imprimir)&imprimir_jugador);
assert(((jugador*)lfil2->primero->sig->sig->datos)->altura==j3->altura);
lista_borrar(lfil2,(tipo_funcion_borrar)&borrar_jugador);
lista_borrar(l,(tipo_funcion_borrar)&borrar_jugador);
}
int testLista()
{
char *nombre = "aaa";
char *pais = "pepe";
jugador *pepe = crear_jugador(nombre ,pais,'4',196);
char *nombre2 = "ccc";
char *pais2 = "pepe";
jugador *pepe2 = crear_jugador(nombre2 ,pais2,'4',196);
char *nombre3 = "bbb";
char *pais3 = "pepe";
jugador *pepe3 = crear_jugador(nombre3 ,pais3,'4',196);
lista *miLista;
printf("Creando Lista...\n");
miLista = lista_crear();
printf("Insertando jugador 1\n");
insertar_ordenado(miLista,(void*)pepe, (tipo_funcion_cmp)&menor_jugador);
printf("Insertando jugador 2\n");
insertar_ordenado(miLista,(void*)pepe2, (tipo_funcion_cmp)&menor_jugador);
printf("Insertando jugador 3\n");
insertar_ordenado(miLista,(void*)pepe3, (tipo_funcion_cmp)&menor_jugador);
lista *backUp = miLista;
miLista = ordenar_lista_jugadores(backUp);
lista_borrar(backUp, (tipo_funcion_borrar)&borrar_jugador);
nodo *unNodo = miLista->primero;
jugador *unj = unNodo->datos;
printf("Nombre: %s \n",unj->nombre);
unNodo = miLista->primero->sig;
unj = unNodo->datos;
printf("Nombre: %s \n",unj->nombre);
unNodo = miLista->primero->sig->sig;
unj = unNodo->datos;
printf("Nombre: %s \n",unj->nombre);
lista* B = mapear(miLista, (tipo_funcion_mapear)&normalizar_jugador);
printf("Borrando Lista...\n");
lista_borrar(B, (tipo_funcion_borrar)&borrar_jugador);
lista_borrar(miLista, (tipo_funcion_borrar)&borrar_jugador);
printf("Ok!\n");
return 0;
}
void listadesels() {
lista* l = lista_crear();
jugador* j1 = crear_jugador("Ginobili", "Argentina", 5, 198);
jugador* j2 = crear_jugador("Scola", "Argentina", 6, 198);
jugador* j3 = crear_jugador("Prigioni", "Argentina", 7, 198);
jugador* j4 = crear_jugador("Ginobili", "Argentina", 9, 199);
jugador* j5 = crear_jugador("Ginobili", "Argentina", 10, 199);
insertar_ordenado(l, (void*)j1, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j2, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j3, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j4, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l, (void*)j5, (tipo_funcion_cmp)&menor_jugador);
seleccion* s=crear_seleccion("Uruguay",altura_promedio(l),l);
lista* l2 = lista_crear();
seleccion* s2=crear_seleccion("Andorra",0,l2);
lista* partido=lista_crear();
insertar_ordenado(partido, (void*)s, (tipo_funcion_cmp)&menor_seleccion);
insertar_ordenado(partido, (void*)s2, (tipo_funcion_cmp)&menor_seleccion);
assert(((seleccion*)partido->primero->datos)->jugadores->primero== NULL);
assert(((seleccion*)partido->primero->sig->datos)->alturaPromedio==(992/5.0));
lista_imprimir(partido, "hola.out",(tipo_funcion_imprimir)&imprimir_seleccion);
lista_borrar(partido,(tipo_funcion_borrar)&borrar_seleccion);
}
int p1()
{
lista *l = lista_crear();
lista_imprimir(l,"test.txt",(tipo_funcion_imprimir)&g);
lista_borrar(l,(tipo_funcion_borrar) &f);
return 0;
}
int testSeleccion()
{
lista* A = lista_crear();
jugador* Gino = crear_jugador("Ginobili", "Argentina", 6, 198);
jugador* GinoPies = normalizar_jugador(Gino);
jugador* Gino2 = crear_jugador("Ginobili", "Argentina", 6, 198);
jugador* GinoPies2 = normalizar_jugador(Gino);
insertar_ordenado(A, (void*)GinoPies, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(A, (void*)Gino, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(A, (void*)GinoPies2, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(A, (void*)Gino2, (tipo_funcion_cmp)&menor_jugador);
seleccion* w = crear_seleccion("Argentina", altura_promedio(A), A);
lista* B = lista_crear();
jugador* a = crear_jugador("a", "Argentina", 6, 143);
jugador* b = normalizar_jugador(Gino);
jugador* c = crear_jugador("b", "Argentina", 6, 400);
jugador* d= normalizar_jugador(Gino);
insertar_ordenado(B, (void*)a, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(B, (void*)b, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(B, (void*)c, (tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(B, (void*)d, (tipo_funcion_cmp)&menor_jugador);
seleccion* j = crear_seleccion("Argentina", altura_promedio(B), B);
lista *listaDeSelecciones = lista_crear();
insertar_ordenado(listaDeSelecciones, w, (tipo_funcion_cmp)menor_seleccion);
insertar_ordenado(listaDeSelecciones, j, (tipo_funcion_cmp)menor_seleccion);
lista_borrar(listaDeSelecciones, (tipo_funcion_borrar)borrar_seleccion);
printf("OK\n");
return 0;
}
void* hash_borrar(hash_t* hash, const char* clave) {
if (!hash_pertenece(hash,clave)) return NULL;
size_t posicion = fhash(clave,hash->tamanio);
lista_iter_t* iter = lista_iter_crear(hash->tabla[posicion]);
nodo_hash_t* nodo = lista_iter_ver_actual(iter);
bool esta = false;
while (!lista_iter_al_final(iter)) {
if (strcmp(nodo->clave,clave) == 0) {
esta = true;
break;
}
lista_iter_avanzar(iter);
nodo = lista_iter_ver_actual(iter);
}
if (esta == false) {
lista_iter_destruir(iter);
return NULL;
}
nodo = (nodo_hash_t*)lista_borrar(hash->tabla[posicion],iter);
void* dato = nodo->dato;
free(nodo->clave);
free(nodo);
lista_iter_destruir(iter);
hash->cantidad --;
return dato;
}
void listavacia() {
FILE* archivo = fopen("hola.out","a");
lista* l = lista_crear();
assert(l->primero == NULL);
lista_imprimir_f(l, archivo, (tipo_funcion_imprimir)&g);
lista_borrar(l,(tipo_funcion_borrar)&f);
fclose(archivo);
}
int p4a(){
lista *l= lista_crear();
lista *jugadores = lista_crear();
seleccion *sel = crear_seleccion("hola", 21.0, jugadores);
insertar_ordenado(l,sel,(tipo_funcion_cmp)&menor_seleccion);
lista_imprimir(l,"p4a.txt",(tipo_funcion_imprimir)&imprimir_seleccion);
lista_borrar(l,(tipo_funcion_borrar) &borrar_seleccion);
return 0;
}
int eliminar_curso(char* idc,base_t* basedatos){
int i;
int pos = existe_curso(idc,basedatos->listadecursos);
if (pos==-1) return -1;
lista_iter_t* iterador = lista_iter_crear(basedatos->listadecursos);
for(i=0;i<pos;i++) lista_iter_avanzar(iterador);
destruir_curso((curso_t*)lista_borrar(basedatos->listadecursos,iterador));
lista_iter_destruir(iterador);
return 0;
}
void listade1(void) {
lista* l = lista_crear();
jugador* j = crear_jugador("Ginobili", "Argentina", 5, 198);
nodo* n=nodo_crear(j);
//insertar_ordenado(l, (void*)Gino, (tipo_funcion_cmp)&menor_jugador);
insertar_ultimo(l, n);
lista_imprimir(l, "hola.out", (tipo_funcion_imprimir)&imprimir_jugador);
assert(((jugador*)l->primero->datos)->nombre == j->nombre);
lista_borrar(l,(tipo_funcion_borrar)&borrar_jugador);
}
int p2()
{
char *nombre = "pepe";
char *pais = "pepe";
jugador *pepe = crear_jugador(nombre ,pais, 4 ,30);
lista *l = lista_crear();
insertar_ordenado(l,pepe,(tipo_funcion_cmp)&menor_jugador);
lista_imprimir(l, "mitest.txt",(tipo_funcion_imprimir) &imprimir_jugador);
lista_borrar(l,(tipo_funcion_borrar) &borrar_jugador);
return 0;
}
int desinscribir(char* padron, char* idc, base_t* basedatos){
int i,posicion;
curso_t* curso = conseguir_curso(idc,basedatos->listadecursos);
if (curso==NULL) return -1;
posicion = alumno_inscripto(padron,curso->inscriptos);
if (posicion==-1) return -2;
lista_iter_t* iterador = lista_iter_crear(curso->inscriptos);
for(i=0;i<posicion;i++) lista_iter_avanzar(iterador);
destruir_inscripto((char*)lista_borrar(curso->inscriptos,iterador));
lista_iter_destruir(iterador);
return 0;
}
int p5(){
char *nombre = "aaa";
char *pais = "pepe";
jugador *pepe = crear_jugador(nombre ,pais, 4 ,30);
char *nombre2 = "aab";
char *pais2 = "pepe";
jugador *pepe2 = crear_jugador(nombre2 ,pais2, 4 ,30);
char *nombre3 = "bbb";
char *pais3 = "pepe2";
jugador *pepe3 = crear_jugador(nombre3 ,pais3, 4 ,30);
lista *l = lista_crear();
insertar_ordenado(l,pepe,(tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l,pepe2,(tipo_funcion_cmp)&menor_jugador);
insertar_ordenado(l,pepe3,(tipo_funcion_cmp)&menor_jugador);
lista *pop = mapear(l, (tipo_funcion_mapear)&normalizar_jugador);
lista_imprimir(pop,"ultimoTest.txt",(tipo_funcion_imprimir)&imprimir_jugador);
lista *l2 = filtrar_jugadores(l, (tipo_funcion_cmp)&pais_jugador,(void*) l->primero);
assert(menor_jugador(l->primero->datos,l2->primero->datos) && menor_jugador(l2->primero->datos,l->primero->datos));
lista_imprimir(l2,"swapsds",(tipo_funcion_imprimir)&imprimir_jugador);
lista_borrar(pop,(tipo_funcion_borrar) &borrar_jugador);
lista_borrar(l2,(tipo_funcion_borrar) &borrar_jugador);
lista_borrar(l,(tipo_funcion_borrar) &borrar_jugador);
return 0;
}
int sesion_deshacer(sesion_t* sesion){
if (strcmp(sesion->padron,"00000")==0) return -1;
if (lista_largo(sesion->inscripciones)==0) return -2;
lista_iter_t* iteradordeprueba = lista_iter_crear(sesion->inscripciones);
lista_iter_t* iteradorreal = lista_iter_crear(sesion->inscripciones);
while(!lista_iter_al_final(iteradordeprueba)){
lista_iter_avanzar(iteradordeprueba);
if (!lista_iter_al_final(iteradordeprueba)) lista_iter_avanzar(iteradorreal);
}
destruir_inscripcion((inscripcion_t*)lista_borrar(sesion->inscripciones,iteradorreal));
//destruir_inscripcion((inscripcion_t*)lista_borrar_primero(sesion->inscripciones));
lista_iter_destruir(iteradordeprueba);
lista_iter_destruir(iteradorreal);
return 0;
}
int testJugadores()
{
lista* A = lista_crear();
jugador* Gino = crear_jugador("Ginobili", "Argentina", 6, 198);
jugador* GinoPies = normalizar_jugador(Gino);
insertar_ordenado(A, (void*)GinoPies, (tipo_funcion_cmp)&menor_jugador);
borrar_jugador(Gino);
Gino = A->primero->datos;
printf("NORMALIZADO\n");
printf("numero: %c \n",Gino->numero);
printf("Nombre: %s \n",Gino->nombre);
printf("Pais: %s \n",Gino->pais);
printf("Altura: %u \n",(unsigned int)Gino->altura);
lista_borrar(A, (tipo_funcion_borrar)&borrar_jugador);
return 0;
}
void hash_destruir(hash_t* hash) {
for (int i = 0; i < hash->tamanio; i ++) {
lista_iter_t* iter = lista_iter_crear(hash->tabla[i]);
while (!lista_iter_al_final(iter)) {
nodo_hash_t* nodo = lista_borrar(hash->tabla[i],iter);
if (hash->destruir_dato) {
hash->destruir_dato(nodo->dato);
}
free(nodo->clave);
free(nodo);
}
lista_iter_destruir(iter);
lista_destruir(hash->tabla[i],NULL);
}
free(hash->tabla);
free(hash);
}
bool cancelar_pedido(vector_t * vectorzonas, char n[], int cantidad, int zona){
pedido_t *auxpedido;
lista_t* listaaux= (lista_t*) vector_obtener(vectorzonas, (zona-1));
lista_iter_t *iter=lista_iter_crear(listaaux);
while (lista_iter_al_final(iter)==false){
auxpedido=(pedido_t*)(lista_iter_ver_actual(iter));
if ( ( (strcmp (auxpedido->nombre,n)==0)) && auxpedido->cantidad==cantidad){
printf("Se borro el pedido, %s",auxpedido->nombre);
lista_borrar(listaaux, iter);
return true;
}
lista_iter_avanzar(iter);
}
return false;
}
void listademas(void) {
lista* l = lista_crear();
jugador* j1 = crear_jugador("Ginobili", "Argentina", 5, 198);
jugador* j2 = crear_jugador("Scola", "Argentina", 6, 190);
jugador* j3 = crear_jugador("Prigioni", "Argentina", 7, 190);
jugador* j4 = crear_jugador("Ginobili", "Argentina", 9, 199);
jugador* j5 = crear_jugador("Ginobili", "Argentina", 10, 202);
insertar_ordenado(l, (void*)j1, (tipo_funcion_cmp)&h); //j1
insertar_ordenado(l, (void*)j2, (tipo_funcion_cmp)&h); //j2->j1 (estoy usando h, que me da que es menor)
insertar_ordenado(l, (void*)j3, (tipo_funcion_cmp)&menor_jugador); //j3->j2->j1
insertar_ordenado(l, (void*)j4, (tipo_funcion_cmp)&menor_jugador); //j4->j3->j2->j1
insertar_ordenado(l, (void*)j5, (tipo_funcion_cmp)&menor_jugador); //j4->j5->j3->j2->j1
assert(((jugador*)l->primero->datos)->altura == j4->altura);
lista_imprimir(l,"hola.out", (tipo_funcion_imprimir)&imprimir_jugador);
lista_borrar(l,(tipo_funcion_borrar)&borrar_jugador);
}
int p3()
{
char *nombre = "aaa";
char *pais = "pepe";
jugador *pepe = crear_jugador(nombre ,pais, 4 ,30);
lista *l = lista_crear();
char *nombre2 = "bbb";
char *pais2 = "pepe";
jugador *pepe2 = crear_jugador(nombre2 ,pais2, 4 ,30);
char *nombre3 = "aaa";
char *pais3 = "pepe";
jugador *pepe3 = crear_jugador(nombre3 ,pais3, 4 ,30);
insertar_ordenado(l,pepe,(tipo_funcion_cmp)&h);
insertar_ordenado(l,pepe2,(tipo_funcion_cmp)&h);
insertar_ordenado(l,pepe3,(tipo_funcion_cmp)&h);
assert(l->primero->sig->sig->datos == pepe);
lista_borrar(l,(tipo_funcion_borrar) &borrar_jugador);
return 0;
}
int p4b(){
lista *jugadores = lista_crear();
lista *l = lista_crear();
char *nombre = "aaa";
char *pais = "pepe";
jugador *pepe = crear_jugador(nombre ,pais, 4 ,30);
char *nombre2 = "bbb";
char *pais2 = "pepe";
jugador *pepe2 = crear_jugador(nombre2 ,pais2, 4 ,30);
insertar_ordenado(jugadores,pepe,(tipo_funcion_cmp)&h);
insertar_ordenado(jugadores,pepe2,(tipo_funcion_cmp)&h);
seleccion *sel = crear_seleccion("hola", 21.0, jugadores);
insertar_ordenado(l,sel,(tipo_funcion_cmp)&menor_seleccion);
lista_imprimir(l,"testSeleccion.txt",(tipo_funcion_imprimir)&imprimir_seleccion);
lista_borrar(l,(tipo_funcion_borrar) &borrar_seleccion);
return 0;
}
hash_t* hash_redimensionar(hash_t* hash, size_t tamanio) {
lista_t** nueva_tabla = creacion_tabla(hash,tamanio);
if (nueva_tabla == NULL) return NULL;
for (int i = 0; i < hash->tamanio; i ++) {
lista_iter_t* iter = lista_iter_crear(hash->tabla[i]);
const char* clave;
size_t posicion;
nodo_hash_t* nodo;
while (!lista_iter_al_final(iter)) {
nodo = lista_borrar(hash->tabla[i],iter);
clave = nodo->clave;
posicion = fhash(clave,tamanio);
lista_insertar_primero(nueva_tabla[posicion],nodo);
}
lista_destruir(hash->tabla[i],NULL);
lista_iter_destruir(iter);
}
free(hash->tabla);
hash->tamanio = tamanio;
hash->tabla = nueva_tabla;
return hash;
}
void enviar(vector_t * vectorzonas, pila_t* pila){
lista_iter_t *iter,*iterborrar;
bool primeroencontrado;
int i,canti,cantf,total;
pedido_t *pedidoaux,*primerpedido,*pedidof;
lista_t* listaaux;
for (i=0;i<vector_obtener_cantidad(vectorzonas);i++){
primeroencontrado=true;
while(primeroencontrado)
{
primeroencontrado=false;
canti=0;
cantf=0;
total=0;
pedidof=NULL;
listaaux= (lista_t*) vector_obtener(vectorzonas, i);
iter=lista_iter_crear(listaaux);
while ( !lista_iter_al_final(iter) )
{
pedidoaux=(pedido_t*) (lista_iter_ver_actual(iter));
if (pedidoaux !=NULL)
{
if ( (!primeroencontrado) && (pedidoaux->preparado))
{
primerpedido=pedidoaux; //primer pedido es el primer pedido preparado de esa zona
canti=pedidoaux->cantidad;
primeroencontrado=true;
}
else if (pedidoaux->preparado)
{
cantf=pedidoaux->cantidad;
if ( ((canti + cantf)<=5) && ((canti+cantf)>total) )
{
pedidof=pedidoaux;
total=canti+cantf;
}
}
}
lista_iter_avanzar(iter);
}
lista_iter_destruir(iter);
if ( (primeroencontrado) && (pedidof!=NULL))
printf("Se envio el pedido %s junto con el pedido %s \n",primerpedido->nombre,pedidof->nombre);
else if (primeroencontrado){
printf("Se envio el pedido %s \n",primerpedido->nombre);
}
iterborrar=lista_iter_crear(listaaux);
while (!lista_iter_al_final(iterborrar))
{
if ( primerpedido==lista_iter_ver_actual(iterborrar) )
{
pila_apilar(pila,primerpedido);
lista_borrar(listaaux,iterborrar);
}
else{
if (pedidof==lista_iter_ver_actual(iterborrar))
{
pila_apilar(pila,pedidof);
lista_borrar(listaaux,iterborrar);
}
else lista_iter_avanzar(iterborrar);
}
}
lista_iter_destruir(iterborrar);
}
}
}
int main(int argc, char *argv[])
{
Producto producto;
int indice, i;
char resp = 's';
lista_borrarLista();
while(resp != 'n')
{
printf("\nIngrese el codigo: ");
scanf("%d", &producto.codigo);
fflush(stdin);
printf("\nIngrese el precio: ");
scanf("%f", &producto.precio);
fflush(stdin);
printf("\nIngrese la posicion en la lista: ");
scanf("%d", &indice);
fflush(stdin);
if(lista_setProducto(&producto, indice) == 0)
printf("\nError\n");
else
printf("\nProducto cargado\n");
printf("\nDesea seguir ingresando productos? s/n: ");
scanf("%c", &resp);
fflush(stdin);
}
printf("\n\nPrecio mas alto de la lista: ");
printf("\nCodigo\tPrecio");
producto = *(lista_getMasCaro());
printf("\n%d\t%.2f", producto.codigo, producto.precio);
printf("\n\nBorra un producto, introduce un indice: ");
scanf("%d", &indice);
if(lista_borrar(&miProducto[indice]) == 0)
printf("\nError");
else
printf("\nProducto borrado");
printf("\n\nObtener un producto, ingrese el indice: ");
scanf("%d", &indice);
if(lista_getProducto(indice) == 0)
printf("\nError");
else
{
producto = *(lista_getProducto(indice));
printf("\n\nCodigo\tPrecio");
printf("\n%d\t%.2f", producto.codigo, producto.precio);
}
printf("\n\n\nLista completa: ");
printf("\n\nCodigo\tPrecio");
for(i = 0; i < TAMANIO; i++)
{
if(miProducto[i].flagLibre == 0)
printf("\n%d\t%.2f\n", miProducto[i].codigo, miProducto[i].precio);
}
printf("\n\nBorrar Lista");
lista_borrarLista();
printf(" \n\nLista borrada");
return 0;
}
/* Pruebas */
void prueba_tipos() {
// Declaro de variables
lista_iter_t *iter;
lista_t* lista;
alumno_t* alumno1;
alumno_t* alumno2;
alumno_t* alumno3;
int padron1=94111;
int padron2=77777;
int padron3=10104;
// las inicializo
lista = lista_crear();
alumno1=alumno_crear(padron1);
alumno2=alumno_crear(padron2);
alumno3=alumno_crear(padron3);
printf("---------------------------PRUEBAS---------------------------\n");
//pruebo que este vacia
print_test("Pruebo que la lista se crea vacía", lista_esta_vacia(lista) );
//inserto 1er elemento
print_test("Inserto primer elemento alumno1", lista_insertar_primero(lista,alumno1) );
//inserto ultimo
print_test("Inserto ultimo elemento alumno2", lista_insertar_ultimo(lista,alumno2) );
//inesrto un nuevo ultimo
print_test("Inserto ultimo elemento alumno3", lista_insertar_ultimo(lista,alumno3) );
//veo el primero
print_test("Veo el primer elemento(alumno1)", alumno1==lista_ver_primero(lista));
//borro el primero y veo devuelta
print_test("Borro el primero", lista_borrar_primero(lista));
print_test("Veo el primer elemento(alumno2)", alumno2==lista_ver_primero(lista));
//veo el largo de la lista
print_test("Veo el largo de la lista (2)", 2==lista_largo(lista));
//creo iterador
iter= lista_iter_crear(lista);
//pruebas del iterador
print_test("Hago avanza al iterador", lista_iter_avanzar(iter));
print_test("Veo elemento actual del iterador (alumno3)", alumno3==lista_iter_ver_actual(iter));
print_test("Hago avanza al iterador", lista_iter_avanzar(iter));
print_test("Veo si esta al final", lista_iter_al_final(iter));
//pruebas de lista junto con iterador
print_test("Inserto de nuevo alumno1", lista_insertar(lista,iter,alumno1));
print_test("Lo borro", alumno1==lista_borrar(lista,iter));
//inserto 1er elemento
print_test("Inserto primer elemento alumno1", lista_insertar_primero(lista,alumno1) );
//destruyo el iterador
lista_iter_destruir(iter);
//creo iterador
iter= lista_iter_crear(lista);
print_test("Destruyo iterador,lo creo devuelta y borro el primer elemento (alumno1)", alumno1==lista_borrar(lista,iter));
destruir_dato(alumno1);
//destruyo lista e iterador
lista_iter_destruir(iter);
lista_destruir(lista,destruir_dato);
}
void lista_prueba(){
//Pruebo crear listas
lista_t* lista1 = lista_crear();
lista_t* lista2 = lista_crear();
lista_t* lista3 = lista_crear();
print_test("Probando si lista1 se creo bien", lista1!=NULL);
print_test("Probando si lista1 esta vacia", lista_esta_vacia(lista1));
print_test("Probando si el largo de lista2 es 0", lista_largo(lista2)==0);
int vector[]={ 1, 2, 3, 4};
char vector2[]="hola que tal";
// Probando insertar en la lista;
print_test("Probando si se inserta al principio un elemento en la lista1", lista_insertar_primero(lista1, &vector));
print_test("Probando si se inserta al final un elemento en la lista1", lista_insertar_ultimo(lista1, &vector2));
// Probando el largo de la lista con 2 elementos
print_test("Probando que el largo de la lista1 sea dos", lista_largo(lista1)==2);
// Probando el lista borrar primero en la lista 1
print_test("Probando si se borra el primer elemento en la lista1", lista_borrar_primero(lista1) == vector);
// Probando el lista ver primero
print_test("Probando ver el primero de la lista 1", lista_ver_primero(lista1) == vector2 );
// Probando agregar al principio en lista 3
print_test("Probando si se inserta al principio un elemento en la lista3", lista_insertar_primero(lista3, &vector));
lista_insertar_ultimo(lista3, &vector2);
// PRUEBAS CON EL ITERADOR CON LA LISTA 3
lista_iter_t* iter = lista_iter_crear(lista3);
// Probando el iter avanzar
print_test("Probando el iter avanzar", lista_iter_avanzar(iter));
// Probando el iter ver actual
print_test("Probando el iter ver actual", lista_iter_ver_actual(iter) == vector2);
// Probando el iter al final
print_test("Probando el iter avanzar", lista_iter_avanzar(iter));
print_test("Probando el iter avanzar (no puede avanzar mas)", lista_iter_avanzar(iter) == false);
print_test("Probando el iter al final", lista_iter_al_final(iter));
print_test("Probando si el iter esta el final el ver_actual", lista_iter_ver_actual(iter) == NULL);
lista_iter_destruir(iter);
// Probando lista_insertar con iterador
lista_iter_t* iter2 = lista_iter_crear(lista2);
char vector3[]="chau";
print_test("Probando el lista_insertar en la lista con el iter", lista_insertar(lista2,iter2,&vector3));
print_test("Probando ver el primero de la lista2", lista_ver_primero(lista2) == &vector3 );
print_test("Probando borrar con el iter", lista_borrar(lista2,iter2) == vector3 );
print_test("Probando el lista_ver_primero con los nodos borrados", lista_ver_primero(lista2) == NULL );
print_test("Probando el largo de una lista vacia", lista_largo(lista2) == 0 );
print_test("Probando el lista_borrar_primero en una lista vacia", lista_borrar_primero(lista2) == NULL );
lista_iter_destruir(iter2);
// Pruebo Agregar 30 Datos y luego borrarlos
for ( int i=0 ; i < 30 ; i++){
lista_insertar_ultimo(lista2, &i);
}
print_test("Probando el largo de la lista2 luego de agregar 30 elementos", lista_largo(lista2) == 30);
lista_iter_t* iter3=lista_iter_crear(lista2);
while (!lista_iter_al_final(iter3)){
lista_borrar(lista2,iter3);
}
print_test("Probando que se borraron todos los elementos" , lista_largo(lista2) == 0);
print_test("Prubando borrar un elemento en una lista vacia" , lista_borrar(lista2,iter3) == NULL);
lista_iter_destruir(iter3);
//Finalmente, pruebo si estan vacias las 3 listas
print_test( "Probando que la lista1 no este vacia", lista_esta_vacia(lista1) == false );
print_test( "Probando que la lista2 este vacia", lista_esta_vacia(lista2) );
print_test( "Probando que la lista3 no este vacia", lista_esta_vacia(lista3) == false );
//Elimino las 3 listas
lista_destruir(lista1, NULL);
lista_destruir(lista2, NULL);
lista_destruir(lista3, NULL);
/* ******************************************************************
* Pruebas con lista 4
* *****************************************************************/
//Creo otra lista y le inserto 10 nodos
lista_t* lista4 = lista_crear();
for( int num=1; num <= 10 ; num++){
int elemento=1;
lista_insertar_ultimo(lista4 , &elemento);
}
print_test("Probando largo de la lista 4", lista_largo(lista4) == 10 );
lista_iter_t* iter4= lista_iter_crear(lista4);
print_test("Probando que se creo el iter 4", iter4!=NULL);
print_test("Probando que el iter 4 no este al final", lista_iter_al_final(iter4) == false);
for (int j=1; j<=10; j++){
lista_iter_avanzar(iter4);
}
print_test("Probando que el iter 4 este al final", lista_iter_al_final(iter4));
char prueba[] = "prueba";
print_test("Probando lista_insertar con el iter al final ", lista_insertar(lista4, iter4, &prueba));
print_test("Probando que el iter 4 no este al final", lista_iter_al_final(iter4) == false);
print_test("Probando avanzar con el iter 4 al final", lista_iter_avanzar(iter4));
print_test("Probando lista_borrar con el iter 4 al final", lista_borrar(lista4,iter4) == NULL);
print_test("Probando lista_insertar con el iter 4 al final ", lista_insertar(lista4, iter4, &prueba));
print_test("Probando lista_borrar con el iter 4", lista_borrar(lista4,iter4) == prueba);
for (int j=0; j<=10; j++){
lista_borrar_primero(lista4);
}
print_test("Probando largo de la lista 4", lista_largo(lista4) == 0 );
// elimino el iter 4
lista_iter_destruir(iter4);
//Elimino la lista
lista_destruir(lista4, free);
/* ******************************************************************
* Pruebas con lista 5
* *****************************************************************/
//Creo otra lista y le inserto 10 nodos
lista_t* lista5 = lista_crear();
// le creo un iter
lista_iter_t* iter5= lista_iter_crear(lista5);
print_test("Probando que se creo el iter 5", iter5!=NULL);
for( int num=1; num <= 10 ; num++){
char elemento2[]="hola";
lista_insertar(lista5, iter5, &elemento2);
}
print_test("Probando largo de la lista 5", lista_largo(lista5) == 10 );
print_test("Probando que el iter 5 no este al final", lista_iter_al_final(iter5) == false);
char prueba2[] = "prueba";
print_test("Probando lista_borrar con el iter 5 al principio", lista_borrar(lista5,iter5) != NULL);
print_test("Probando lista_insertar con el iter 5 al principio", lista_insertar(lista5, iter5, &prueba2));
print_test("Probando lista_borrar con el iter 5 ", lista_borrar(lista5,iter5) == prueba2);
for (int j=0; j<=10; j++){
lista_borrar(lista5, iter5);
}
print_test("Probando largo de la lista 5", lista_largo(lista5) == 0 );
print_test("Probando que la lista 5 este vacia", lista_esta_vacia(lista5));
print_test("Probando lista ver_primero de la lista 5", lista_ver_primero(lista5) == NULL);
print_test("Probando avanzar con el iter 5 al final", lista_iter_avanzar(iter5) == false);
print_test("Probando avanzar con el iter 5 al final", lista_iter_ver_actual(iter5) == NULL);
// elimino el iter 5
lista_iter_destruir(iter5);
//Elimino la lista
lista_destruir(lista5, free);
/* ******************************************************************
* Pruebas con lista 6
* *****************************************************************/
// Creo una nueva Lista
lista_t* lista6 = lista_crear();
// le creo un iter
lista_iter_t* iter6= lista_iter_crear(lista6);
print_test("Probando que se creo el iter 6", iter6!=NULL);
void* elemento = malloc(sizeof(void*)) ;
print_test("Probando agregar un elemento con lista_insertar con la lista 6 vacia", lista_insertar(lista6, iter6, elemento));
print_test("Probando largo de la lista 6", lista_largo(lista6) == 1 );
print_test("Probando que el iter 6 no este al final", lista_iter_al_final(iter6) == false);
print_test("Probando si puedo avanzar con el iter 6", lista_iter_avanzar(iter6));
print_test("Probando que el iter 6 este al final", lista_iter_al_final(iter6));
void* borrar=lista_borrar_primero(lista6);
free(borrar);
// elimino el iter 6
lista_iter_destruir(iter6);
//Elimino la lista 6
lista_destruir(lista6, free);
/* ******************************************************************
* Pruebas con lista 7
* *****************************************************************/
lista_t* lista7 = lista_crear();
for (int x=1 ; x<=10 ; x++){
lista_insertar_primero(lista7, &x);
}
lista_iter_t* iter7 = lista_iter_crear(lista7);
print_test("Probando que el largo de la lista7 sea 10", lista_largo(lista7) == 10);
while (!lista_iter_al_final(iter7)){
lista_iter_avanzar(iter7);
}
void* y;
print_test("Probando si se puede ver el elemento actual del iter", lista_iter_ver_actual(iter7) == NULL);
print_test("Probando insetar un elemento al final de la lista7", lista_insertar(lista7, iter7, &y));
print_test("Probando que el largo de la lista7 sea 11", lista_largo(lista7) == 11);
print_test("Probando borrar el ultimo elemento de lista7", lista_borrar(lista7,iter7) == &y);
print_test("Probando que el largo de la lista7 sea 10", lista_largo(lista7) == 10);
print_test("Probando insetar un elemento al final de la lista7", lista_insertar(lista7, iter7, &y));
print_test("Probando que el iter7 no quede al final", lista_iter_al_final(iter7) == false);
lista_iter_destruir(iter7);
lista_destruir(lista7, NULL);
/* ******************************************************************
* Pruebas con lista 8
* *****************************************************************/
lista_t* lista8 = lista_crear();
for (int x=1 ; x<=5 ; x++){
lista_insertar_ultimo(lista8, &x);
}
print_test("Probando que el largo de la lista8 sea 5", lista_largo(lista8) == 5);
lista_iter_t* iter8 = lista_iter_crear(lista8);
int elem=0;
print_test("Probando que el elemento actual del iter8 no es null", lista_iter_ver_actual(iter8) != NULL);
print_test("Probando insertar al principio con el iter en lista8", lista_insertar(lista8, iter8, &elem));
print_test("Probando que el largo de lista8 sea 6", lista_largo(lista8) == 6);
print_test("Probando eliminar el primer elemento de la lista8 con el iter", lista_borrar(lista8, iter8) == &elem);
print_test("Probado que el largo de la lista8 es 5", lista_largo(lista8) == 5);
print_test("Probando insertar un elemento en la primera posicion de lista8", lista_insertar_primero(lista8, &elem));
print_test("Probando que el actual del iter8 sea distinto que el primero de lista8", lista_ver_primero(lista8) != lista_iter_ver_actual(iter8));
lista_iter_destruir(iter8);
lista_destruir(lista8 , NULL);
/* ******************************************************************
* Pruebas con lista 9
* *****************************************************************/
lista_t* lista9 = lista_crear();
int num;
print_test("Probando insertar el elemento en la lista9", lista_insertar_primero(lista9, &num));
print_test("Probando que el largo de lista9 es 1", lista_largo(lista9));
lista_iter_t* iter9 = lista_iter_crear(lista9);
print_test("Probando que el elemento actual del iter9 no es null", lista_iter_ver_actual(iter9) != NULL);
print_test("Probando borrar el elemento de lista9 con el iter", lista_borrar(lista9, iter9) == &num);
print_test("Probando que el largo de lista9 es 0", lista_largo(lista9) == 0);
print_test("Probando borrar un elemento de la lista9 que esta vacia", lista_borrar(lista9, iter9) == NULL);
print_test("Probando avanzar en lista9 que esta vacia", lista_iter_avanzar(iter9) == false);
print_test("Probando agregar un elemento con el iter9", lista_insertar(lista9, iter9, &num));
print_test("Probando eliminar el ultimo elemento con el iter9", lista_borrar(lista9, iter9) == &num);
print_test("Probando agregar un elemento en la lista9", lista_insertar_primero(lista9, &num));
print_test("Probando eliminar el ultimo elemento con borrar primero", lista_borrar_primero(lista9) == &num);
lista_iter_destruir(iter9);
lista_destruir(lista9 , NULL);
lista_t* lista10= lista_crear();
int i=0;
print_test("Probando agregar un elemento a lista10", lista_insertar_primero(lista10 , &i));
print_test("Probando eliminar primer elemento", lista_borrar_primero(lista10) != NULL);
lista_destruir(lista10, NULL);
}
int main(void) {
// COMPLETAR AQUI EL CODIGO
/*
trie *t = trie_crear();
trie_agregar_palabra(t,"gato");
trie_agregar_palabra(t,"auto");
trie_agregar_palabra(t,"automata");
trie_agregar_palabra(t,"autor");
trie_agregar_palabra(t,"gorrion");
trie_agregar_palabra(t,"autora");
trie_agregar_palabra(t,"n***a");
trie_agregar_palabra(t,"fuah");
trie_agregar_palabra(t,"asdjgljsdkg");
trie_agregar_palabra(t,"topcucurrucu");
trie_agregar_palabra(t,"apepepsdf");
trie_agregar_palabra(t,"faspl");
trie_agregar_palabra(t,"zsjgiojds");
trie_agregar_palabra(t,"djgojsgs");
trie_agregar_palabra(t,"mememoforks");
*/
trie *t2 = trie_construir("./test.txt");
trie_imprimir(t2, "./test.txt");
/*
char *larga= (char*)malloc(1080);
int i;
for(i=0;i<1079;i++) {
larga[i] = 'a';
}
larga[i] = 0;
trie_agregar_palabra(t,larga);
int longit = contar(larga);
printf("larga = %d\n",longit);
listaP *sth = palabras_con_prefijo(t, "au");
double sum = peso_palabra("gato") + peso_palabra("auto") + peso_palabra("automata") + peso_palabra("autor") + peso_palabra("gorrion") +peso_palabra("autora") + peso_palabra(larga) ;
*/
double (*funct)(char*);
funct = peso_palabra;
/*
double res = trie_pesar(t, funct);
double res2 = sum /(double) 7 ;
printf("PESO TRIE: %f \n", res);
printf("PESO TRIE c: %f \n", res2);
trie_imprimir(t, "./test.txt");
*/
double res3 = trie_pesar(t2, funct);
printf("PESO TRIE: %f \n", res3);
listaP *s = predecir_palabras(t2, "92");
//free(larga);
//lista_borrar(sth);
lista_borrar(s);
//trie_borrar(t);
trie_borrar(t2);
return 0;
}
