Algoritmos y Progamación II - 1C2023

TP0: Michelle Melisa Chen - 105506 - mchen@fi.uba.ar

• Para compilar y correr las pruebas con valgrind:

make

• Solamente compilar las pruebas:

make pruebas_chanutron

---

Funcionamiento

En el archivo 'tp0.c':

• La fucnión '*hospital_crear' recibe como parámetro '*pokemones', 'cantidad_pokemones' y 'cantidad_entrenadores' para la creación de un hospital. Antes de pedir memoria para crear el hospital, evalúo si puntero '*pokemones' es NULL, en caso, de que lo sea, devuelva 0.

  Con 'malloc' pido memoria del tamaño de la estructura 'hospital_t' y verifico si el pedido de la memoria fue exitoso, en caso de que no lo fuera, devuelva 0.

  Inicializo las variables '*pokemones', 'cantidad_pokemon' y 'cantidad_entrenadores' de la estructura 'hospital_t' con los parámetros pasados. Como por default los pokemones de '*pokemones' pasado por parametro están ordenados no fue necesario ordenarlos antes de pasar al hospital->pokemones.

  hospital_t *hospital_crear(pokemon_t *pokemones, size_t cantidad_pokemones,
                           size_t cantidad_entrenadores) {
  if (pokemones == NULL)
    return 0;

  hospital_t *hospital = malloc(sizeof(hospital_t));

  if (hospital == NULL)
    return 0;

  hospital->pokemones = pokemones;
  hospital->cantidad_pokemon = cantidad_pokemones;
  hospital->cantidad_entrenadores = cantidad_entrenadores;
  return hospital;
}

---

• La función 'hospital_cantidad_entrenadores' recibe '*hospital', verifico, entonces, si el puntero es NULL en caso positivo, devulve 0. Sino la función de vuelve la cantidad de entrenadores que tiene hospital.

size_t hospital_cantidad_entrenadores(hospital_t *hospital) {
  if (hospital == NULL)
    return 0;
  return hospital->cantidad_entrenadores; // funciona siempre?
}

---

• La función 'hospital_cantidad_pokemones' recibe '*hospital', verifico, entonces, si el puntero es NULL en caso de ser positivo, devuelve 0. Sino la función devuelve la cantidad de pokemones que tiene hospital.

size_t hospital_cantidad_pokemones(hospital_t *hospital) {
  if (hospital == NULL)
    return 0;
  return hospital->cantidad_pokemon;
}

---

• La función 'hospital_a_cada_pokemon' recibe '*hospital', el puntero a una función '*funcion' y '*aux'. Como recibo punteros, verifico si 'hospital' y 'funcion' son NULL, en caso de serlo devulve 0.

  Creo una variable size_t i. Uso 'for' para recorrer por los pokemones guardados en '*hospital'. Para i = 1, si i es menor que la cantidad de pokemones en hospital, evalúo si aplicando la función 'funcion' al pokemon me devulve True, en caso de serlo continúa con el proximo pokemón, en caso contrario, devuelve el contador i (registra la cantidad de pokemones aplicada la función dá True).

  Si todos todos los pokemones del de la '*pokemones' aplicada la función 'funcion' da True, también devuelvo el contador i

size_t hospital_a_cada_pokemon(hospital_t *hospital,
                              bool (*funcion)(pokemon_t *p, void *aux),
                              void *aux) {
 if (hospital == NULL || funcion == NULL)
   return 0;

 size_t i;
 for (i = 1; i < hospital->cantidad_pokemon; i++) {
   if (!funcion(hospital->pokemones + i - 1, aux))
     return i;
 }
 return i;
}

---

• La función 'pokemones_comparar' recibe dos punteros '*pokemon1' y '*pokemon2' y devuelve si son idénticos. Verifico si 'pokemon1' es NULL o 'pokemon2' es NULL, en caso de ser positivo, devolver False.

  En 'if' uso '==' para comparar si el 'id' y la 'salud' de los dos pokemones son iguales, y uso 'strcmp' igualándolo a 0 para comparar si el nombre del entrenador de los dos pokemones.

bool pokemones_comparar(pokemon_t *pokemon1, pokemon_t *pokemon2) {
  if (pokemon1 == NULL || pokemon2 == NULL)
    return false;

  if (pokemon1->id == pokemon2->id && pokemon1->salud == pokemon2->salud &&
      strcmp(pokemon1->nombre_entrenador, pokemon2->nombre_entrenador) == 0)
    return true;
  return false;
}

---

• La función 'pokemon_copiar' un puntero a una estructura 'pokemon_t' y una estructura 'pokemon_t'. Saqué la evaluación de si 'poke_origen == NULL' porque no es un puntero.

bool pokemon_copiar(pokemon_t *poke_destino,
                    pokemon_t poke_origen) { // funciona
  if (poke_destino == NULL)
    return false;

  poke_destino->id = poke_origen.id;
  poke_destino->salud = poke_origen.salud;
  strcpy(poke_destino->nombre_entrenador, poke_origen.nombre_entrenador);
  return true;
}

---

• Evalúo si '*hospital' y '*pokemones_ambulancia' son NULL, en caso positivo, devolver ERROR.

  Creo una variable 'pokemon_t *pokemones_aux' para almacer la dirección que me devulve 'realloc' que intenta expandir el espacio de memoria reservada para 'hospital->pokemones', la memoria a reservar ahora sería 'hospital->cantidad_pokemones + cant_pokes_ambulancia', es decir, la cantidad de pokemones que ya había en el hospital sumado a los nuevos que entran en la ambulancia, esa nueva cantidad multiplicada al tamaño de un 'pokemon_t' sería la total de memoria a reservar.

  Evaluó, después, si la reserva de memoria fue exitosa, en caso de no serlo, devolver ERROR.
  Si la reserva fue exitosa, entonces igualo 'hospital->pokemones' a 'pokemones_aux'.

  Agrego a los nuevos pokemones en ambulancia con un ciclo 'for'. Para el contador i = 1, si i es menor o igual que la cantidad de pokemones en ambuncia, a partir de 'hospital->pokemones[hospital->cantidad_pokemon + i]' voy almacenando uno por uno los pokemones en la ambulancia.

  Actualizo la cantidad de pokemones y cantidad de entrenadores en el hospital una vez finalizada la carga.

  Ordeno los 'pokemon_t' en 'hospital->pokemones' usando 'qsort'. Creo la función 'comparar_pkm_salud' que compara la salud de cada pokemon y los ordena de menor a mayor.

int comparar_pkm_salud(const void *p, const void *q)
{
	int pkm_1 = (int)((pokemon_t *)p)->salud;
	int pkm_2 = (int)((pokemon_t *)q)->salud;
	return (pkm_1 - pkm_2);
}

int hospital_aceptar_emergencias(hospital_t *hospital, pokemon_t *pokemones_ambulancia, size_t cant_pokes_ambulancia,
				 size_t cant_nuevos_entrenadores)
{
	if (hospital == NULL || pokemones_ambulancia == NULL)
		return ERROR;

	pokemon_t *pokemones_aux =
		realloc(hospital->pokemones, (hospital->cantidad_pokemon + cant_pokes_ambulancia) * sizeof(pokemon_t));

	if (pokemones_aux == NULL) 
		return ERROR;
	
	hospital->pokemones = pokemones_aux;

	for (size_t i = 1; i <= cant_pokes_ambulancia; i++)
		hospital->pokemones[hospital->cantidad_pokemon + i] = pokemones_ambulancia[i - 1];

	hospital->cantidad_pokemon += cant_pokes_ambulancia;
	hospital->cantidad_entrenadores += cant_nuevos_entrenadores;

	qsort(hospital->pokemones, hospital->cantidad_pokemon, sizeof(pokemon_t), comparar_pkm_salud);
	return EXITO;
}