Segundo Parcial 1C 2024 ejercicio 1

Esta bien?

*
//aeropuertos

typedef struct node{
    char * name;
    struct node * tail;
}TNode;

typedef TNode * TList;

typedef struct counter{
    TList first;
    TList last;
    TList iter;
    size_t waitingPassengers;
}TCounter;

struct countersCDT{
    TCounter * counters; //vector de mostradores
    size_t maxCounters;
}

/*
* Crea un sistema de administración de mostradores a partir de la cantidad
* máxima #maxCounters de mostradores que tendrá el aeropuerto.
* Se asume que la gran mayoría de los mostradores serán utilizados por las aerolíneas.
* Si maxCounters es cero retorna NULL.
*/
countersADT newCounters(size_t maxCounters){
    if (maxCounters == 0)
        return NULL;

    countersADT new = malloc(sizeof(struct countersCDT));
    new->maxCounters = maxCounters;
    new->counters = calloc(1, sizeof(TCounter) * maxCounters);
    return new;
}

/*
* Ingresa al pasajero #passenger en la cola de espera del mostrador #counterNumber
* para luego poder hacer el checkIn de su vuelo.
* Un mismo pasajero puede ingresar múltiples veces al mismo mostrador o a varios
* mostradores distintos.
* Se asume que los nombres de los pasajeros son cortos.
* Falla si #counterNumber es mayor o igual a la cantidad máxima de mostradores.
*/
#define IS_VALID_NUMBER(size_t num, size_t max)((num) < (max))

void enterCounter(countersADT counters, size_t counterNumber, const char * passenger){
    if (!IS_VALID_NUMBER(counterNumber, counters->maxCounters))
        exit(1);

    TList newPassenger = malloc(sizeof(TNode));
    newPassenger->name = malloc(sizeof(char) * strlen(passenger));;
    //hago una copia del nombre
    strcpy(newPassenger->name, passenger);

    //caso en que no hay nadie en la fila entonces first y last apuntan al mismo
    if (counters->counters[counterNumber]->first == NULL){
        counters->counters[counterNumber]->first = newPassenger;
        counters->counters[counterNumber]->last = newPassenger;
    }else{
        TList aux = counters->counters[counterNumber]->last;
        aux->tail = newPassenger;
        counters->counters[counterNumber]->last = newPassenger;
    }
    newPassenger->tail = NULL;
}

/*
* Funciones de iteración para poder consultar para un mostrador los pasajeros que están
* esperando, en ORDEN DE LLEGADA (ver ejemplo en programa de prueba)
*/
void toBeginByCounter(countersADT counters, size_t counterNumber){
    if (!IS_VALID_NUMBER(counterNumber, counters->maxCounters))
        exit(1);

    if (counters->counters[counterNumber] != NULL){
        counters->counters[counterNumber]->iter = counters->counters[counterNumber]->first;
    }
}
size_t hasNextByCounter(const countersADT counters, size_t counterNumber);
const char * nextByCounter(countersADT counters, size_t counterNumber);

/*
* Para cada mostrador, realiza el checkIn del pasajero que está esperando primero en la
* cola, si es que hay al menos un pasajero esperando en ese mostrador.
* Retorna un arreglo donde, para cada mostrador donde se hizo checkIn, se indica:
* - El número del mostrador
* - El nombre del pasajero que hizo checkIn en el mostrador y salió de la cola de espera
* - La cantidad de pasajeros esperando en el mostrador luego de la operación
* respetando el ORDEN ASCENDENTE por número de mostrador
* Deja en un parámetro de entrada/salida la dimensión del vector de retorno
*/

struct checkInResult {
    size_t counterNumber;
    const char * checkedInPassenger;
    size_t waitingPassengers;
};
struct checkInResult * checkInCounters(countersADT counters, size_t * checkInResultDim){
    //realiza el check-in si es que hay al menos un pasajero en la cola (first != NULL)
    struct checkInResult * v = malloc(sizeof(struct checkInResult));
    int i = dim = 0;
    while (counters->counters[i] != NULL){
        if (counters->counters[i]->first != NULL){
            //hago una copia del nombre del primero
            v[dim].checkedInPassenger = malloc(sizeof(char) * (strlen(counters->counters[i]->first->name) + 1));
            strcpy(v[dim].checkedInPassenger ,counters->counters[i]->first->name);
            v[dim].counterNumber = i;
            (counters->counters[i].waitingPassengers)--;
            v[dim].waitingPassengers = counters->counters[i].waitingPassengers;
            dim++;
            //elimino el actual y paso al siguiente
            TList aux = counters->counters[i]->first;
            counters->counters[i]->first = aux->tail;
            if (aux->tail == NULL){
                //es el ultimo en hacer el check in -> la lista queda vacia 
                counters->counters[i]->last = NULL;
            }
            free(aux);
        }
        i++;
    }
    *checkInResultDim = dim;
    return v;
}
*
PI-ITBA / 2024_01

Segundo Parcial 1C 2024 ejercicio 1 #367
