====== Examen Parcial - 75.41. Algoritmos y Programación II ======

**Cátedra:** Mandrafina\\
**Fecha:** Primera Oportunidad - Primer Cuatrimestre 2005\\
**Día:** 20/05/2005

<note important>
Esta página está incompleta; podés ayudar completando el material.
</note>

===== Enunciado =====

==== Punto I ====

Dado el siguiente programa se requiere indicar lo que se mostraría por pantalla:

<code cpp>
#include <stdlib.h>
#include <iostream>

using namespace std;

typedef int* Pint;
typedef char* Pchar;

/*Datos:
 '@' es 64
 'A' es 65
 ...
*/

int main(){
  Pint A,C,F;
  Pint* B;
  Pchar D,E;
  char G;
  int H;

  H = 68;
  G = 'B';
  A = new int;
  *A = 65;
  B = &C;
  F = A;
  C = &H;
  cout << **B << *A << endl;

  D = (char*)*B;
  E = (char*)A;
  cout << *D << *C << *E << endl;

  *D = G;
  if (*C == 68)
      cout << *E << *C << endl;
  
  *A = 67;
  while (*A > 0){
   cout << *A << *E << endl;
   *F = *F - H;
   *A = *A - 1;
  }
  delete A;
}
</code>

==== Punto II ====

Construir los TDAs que modelen un **Contenedor** a partir de la siguiente descripción:
  * Un Contenedor tiene forma cilíndrica, se identifica con un número, y se utiliza para almacenar sustancias líquidas.
  * Cada Contenedor cuenta con un conjunto de Sensores Térmicos.
    * Un **Sensor** se identifica por un número, registra una temperatura, y puede estar encendido o apagado. Se pueden agregar o sacar Sensores de un Contenedor.
  * La temperatura de un Contenedor se calcula como el promedio de los valores de temperatura de sus Sensores encendidos, y la capacidad medida en <tex>m^3</tex> está dada por sus dimensiones físicas.

==== Punto III ====
La empresa  de  Seguridad Industrial  Algoritmia S.A.,  que se dedica  a  controlar  el estado de Contenedores para sustancias líquidas, requiere un informe  con la cantidad de Contenedores que superan una temperatura crítica T dada, para cada empresa en donde se encuentran emplazados.  El informe debe tener el siguiente formato: 

^  Nombre de la Empresa  ^  Dirección  ^  Teléfono  ^  Contacto Técnico  ^  Cantidad de contenedores que superan T  ^


 
El listado debe estar ordenado primero por  cantidad decreciente y segundo por nombre de  empresa creciente.

Se dispone de 3 archivos totalmente desordenados, con la siguiente estructura, donde los campos que aparecen en negrita tienen valores únicos: 

^  Empresa  ^  Contenedor  ^  Sensor  ^
|**Código de Empresa**  (int) |**Código de Contenedor**  (int)|**Código de Contenedor**  (int)|
|Nombre  (char[10])|Alto  (int)|**Código de Sensor**  (int)|
|Razón Social  (char[50])|Radio  (int)|Activado  (bool)|
|Dirección  (char[50])|Sustancia  (char[5])|Temperatura  (float)|
|Teléfono  (char[10])|Código de Empresa  (int)| |
|Contacto técnico  (char[100])| | |

Nota: 
  - Explicar la estrategia de solución adoptada con claridad (usar esquemas) 
  - Los archivos se procesarán secuencialmente, una sola vez, luego en forma directa 
  - Completar todo lo necesario para la resolución del problema, tipos, variables, procedimientos, etc. 

===== Resolución =====

==== Punto I ====
<box 99% shell round>
<code>
6865
D68A
67C
</code>
</box>

==== Punto II ====

Implementación del **TDA Contenedor**. Observar que está pensado para ser usado como objeto, utilizando punteros a Contenedor.

<code cpp>
#include "contenedor.h"
#include <iostream>
#include "sensor.h"

#ifndef PI
#define PI 3.14159
#endif

/* ListaSensores es una lista cuyo dato tiene la siguiente definición
struct Dato{
    Sensor* sensor;
}
El ordenamiento de esa lista se hace por código de sensor
*/
struct Contenedor {
    int codigo;
    float radio;
    float alto;
    std::string sustancia;
    ListaSensores sensores;
};

/*
Pre: Ninguna
Post: Crea un nuevo contenedor, identificado con el código pasado, dejándolo listo para su uso
*/
void crear(Contenedor* &miContenedor, int codigo, float radio, float alto) {
    miContenedor = new Contenedor;
    miContenedor->codigo = codigo;
    miContenedor->radio = radio;
    miContenedor->alto = alto;
    miContenedor->sustancia = "Vacio";
    crearLista(miContenedor->sensores);
}

/*
Pre: El contenedor debe haber sido creado
Post: El contenedor queda destruido e inutilizado para su uso
*/
void destruir(Contenedor* &miContenedor) {
    Dato datoSensor;
    ptrNodoLista ptrSensor;
    
    ptrSensor = primero(miContenedor->sensores);
    while (ptrSensor != fin(miContenedor->sensores)) {
        obtenerDato(miContenedor->sensores,datoSensor,ptrSensor);
        destruir(datoSensor.sensor);
        ptrSensor = siguiente(miContenedor->sensores,ptrSensor);
    }
    eliminarLista(miContenedor->sensores);
    delete miContenedor;
    miContenedor = NULL;
}

/*
Pre: El contenedor debe haber sido creado
Post: Se le asigna la sustancia pasada al contenedor
*/
void setSustancia(Contenedor* &miContenedor, string sustancia) {
    miContenedor->sustancia = sustancia;
}

/*
Pre: El contenedor debe haber sido creado, al igual que el sensor a agregar
Post: Agrega el sensor a los pertenecientes al Contenedor
*/
void agregarSensor(Contenedor* &miContenedor, Sensor* &miSensor) {
    Dato datoSensor;
    
    datoSensor.sensor = miSensor;
    insertarDato(miContenedor->sensores,datoSensor);
}

/*
Pre: El contenedor debe haber sido creado, al igual que el sensor a quitar
Post: Si el sensor existía en el contenedor, es quitado y retorna True. En caso contrario retorna false
*/
bool quitarSensor(Contenedor* &miContenedor, Sensor* &miSensor) {
    Dato datoSensor;
    ptrNodoLista ptrSensor;
    bool encontrado = false;
    
    ptrSensor = primero(miContenedor->sensores);
    while  ((ptrSensor != fin(miContenedor->sensores)) && (!encontrado)) {
        obtenerDato(miContenedor->sensores,datoSensor,ptrSensor);
        if (sonIguales(datoSensor.sensor,miSensor)) {
            encontrado = true;
            destruir(datoSensor.sensor);
            eliminarNodo(miContenedor->sensores,ptrSensor);
        }
        ptrSensor = siguiente(miContenedor->sensores,ptrSensor);
    }
    return encontrado;
}

/*
Pre: El contenedor debe haber sido creado
Post: Retorna el código del Contenedor
*/
int getCodigo(Contenedor* &miContenedor) {
    return miContenedor->codigo;
}

/*
Pre: El contenedor debe haber sido creado
Post: Retorna el radio del Contenedor
*/
float getRadio(Contenedor* &miContenedor) {
    return miContedor->radio;
}

/*
Pre: El contenedor debe haber sido creado
Post: Retorna el alto del Contenedor
*/
float getAlto(Contenedor* &miContenedor) {
    return miContenedor->alto;
}

/*
Pre: El contenedor debe haber sido creado
Post: Retorna el volumen del Contenedor
*/
float getVolumen(Contenedor* &miContenedor) {
    float base;
    base = getRadio(miContenedor);
    base *= base*PI;
    return base*getAlto(miContenedor);
}

/*
Pre: El contenedor debe haber sido creado
Post: Retorna el nombre de la sustancia guardada en el contenedor
*/
string getSustancia(Contenedor* &miContenedor) {
    return miContenedor->sustancia;
}

/*
Pre: El contenedor debe haber sido creado
Post: Retorna la temperatura promedio del Contenedor
*/
float getTemperaturaPromedio(Contenedor* &miContenedor) {
    Dato datoSensor;
    ptrNodoLista ptrSensor;
    int cantidadSensores = 0;
    float temperaturaTotal = 0;
    
    ptrSensor = primero(miContenedor->sensores);
    while (ptrSensor != fin(miContenedor->sensores)) {
        obtenerDato(miContenedor->sensores,datoSensor,ptrSensor);
        if (getEstado(datoSensor.sensor)) {
            cantidadSensores++;
            temperaturaTotal += getTemperatura(datoSensor.sensor);
        }
        ptrSensor = siguiente(miContenedor->sensores,ptrSensor);
    }
    if (cantidadSensores != 0) {
        return (temperaturaTotal/cantidadSensores);
    }
    else {
    return ERROR:
    }
}
</code>

Implementación del **TDA Sensor**. Observar que está pensado para ser usado como objeto, utilizando punteros a Sensor.
<code cpp>
const float ERROR = -999999;

struct Sensor {
    int codigo;
    bool activado;
    float temperatura;
};

/*
Pre: Ninguna
Post: Crea un nuevo sensor, identificado con el código pasado, dejándolo listo para su uso.
Por defecto el sensor está desactivado y la temperatura marcada es ERROR
*/
void crear(Sensor* &miSensor, int codigo) {
    miSensor = new Sensor;
    miSensor->codigo = codigo;
    miSensor->activado = false;
    miSensor->temperatura = ERROR;
}

/*
Pre: El sensor debe haber sido creado
Post: Destruye el sensor, dejándolo intulizable
*/
void destruir(Sensor* &miSensor){
    delete miSensor;
    miSensor = NULL;
}

/*
Pre: El sensor debe haber sido creado
Post: Activa el sensor
*/
void activar(Sensor* &miSensor){
    miSensor->activado = true;
}

/*
Pre: El sensor debe haber sido creado
Post: Desactiva el sensor
*/
void desactivar(Sensor* &miSensor){
        miSensor->activado = false;
}

/*
Pre: El sensor debe haber sido creado
Post: Cambia la temperatura marcada por el sensor
*/
void setTemperatura(Sensor* &miSensor, float temperatura){
    miSensor->temperatura = temperatura;
}

/*
Pre: El sensor debe haber sido creado
Post: Retorna el código del sensor
*/
int getCodigo(Sensor* &miSensor){
    return miSensor->codigo;
}

/*
Pre: El sensor debe haber sido creado
Post: Retorna el estado del sensor:
    True: Activado
    False: Desactivado
*/
bool getEstado(Sensor* &miSensor){
    return miSensor->estado;
}

/*
Pre: El sensor debe haber sido creado
Post: Retorna la temperatura medida actualmente por el sensor
*/
float getTemperatura(Sensor* &miSensor){
    return miSensor->temperatura;
}

/*
Pre: Los dos sensores deben haber sido creados
Post: Retorna true si los sensores son iguales, false en caso contrario
*/
bool sonIguales(Sensor* &a, Sensor* &b){
    return (getCodigo(a) == getCodigo(b);
}
</code>

===== Discusión =====

<note warning>
Si ves algo que te parece incorrecto en la resolución y no te animás a cambiarlo, dejá tu comentario acá </note>