Búsqueda

{
    Se dispone de una estación meteorológica que cada media hora, se registran los valores de todos los sensores y se
    almacenan en una memoria. Completado el día y cada 24hs, reporta sus mediciones en forma de archivo de texto.
    Este archivo contiene tres campos por línea:
        - Horario de registro: en formato HHMM
        - Temperatura en grados Celsius
        - Humedad relativa en %
    Se pide escribir un programa que permita cargar esos datos en vectores paralelos para poder determinar:
        1) Mostrar los datos cargados en un tabla
        2) Mostrar las mediciones para un horario que ingresa el usuario por teclado (hora y minuto por separado).
        Verificar que el horario ingresado sea correcto (minutos entre 0 y 59 y horas entre 0 y 23).
}

program sensores;

type
    TVectorHorario = array[1..50] of Word;
    TVectorMedicion = array[1..50] of Real;

var
    g_cantidad: Byte;
    g_vec_hora: TVectorHorario;
    g_vec_temp, g_vec_hum: TVectorMedicion;
    g_opcion: Char;

procedure cargar_datos(var cantidad: Byte; var vec_hora: TVectorHorario;
        var vec_temp: TVectorMedicion; var vec_hum: TVectorMedicion);

var
    archivo: Text;

begin
    assign(archivo, 'datos.txt');
    reset(archivo);

    cantidad := 0;
    while not eof(archivo) do
    begin
        cantidad := cantidad + 1;
        readln(archivo, vec_hora[cantidad], vec_temp[cantidad], vec_hum[cantidad]);
    end;
end;

procedure mostrar_en_tabla(cantidad: Byte; vec_hora: TVectorHorario;
        vec_temp: TVectorMedicion; vec_hum: TVectorMedicion);

var
    i: Byte;

begin
    writeln('Horario|Temperatura|Humedad');
    writeln('-------+-----------+-------');
    for i := 1 to cantidad do
    begin
        writeln(vec_hora[i]:7, '|', vec_temp[i]:11:2, '|', vec_hum[i]:7:2);
    end;
end;

function busqueda_secuencial(horario: Word; cantidad: Byte; vec_hora: TVectorHorario): Byte;
var
    i: Byte;
begin
    i := 1;
    while (i <= cantidad) and (horario <> vec_hora[i]) do
    begin
        i := i + 1;
    end;
    busqueda_secuencial := i;
end;

function busqueda_binaria(horario: Word; cantidad: Byte; vec_hora: TVectorHorario): Byte;
var
    a, b, m: Byte;
begin
    a := 1;
    b := cantidad;
    m := (a + b) div 2;
    while (a < b) and (horario <> vec_hora[m]) do
    begin
        if horario < vec_hora[m] then
        begin
            b := m - 1;
        end
        else
        begin
            a := m + 1;
        end;
        m := (a + b) div 2;
    end;

    if vec_hora[m] = horario then
        busqueda_binaria := m
    else
        busqueda_binaria := cantidad + 1;
end;

procedure buscar_horario(cantidad: Byte; vec_hora: TVectorHorario;
        vec_temp: TVectorMedicion; vec_hum: TVectorMedicion);

var
    hora, minutos, i: Byte;
    horario: Word;

begin
    write('Ingrese la hora (0 - 23):');
    readln(hora);

    while hora >= 24 do
    begin
        write('Ingresó mal la hora. Por favor vuelva a ingresar la hora: ');
        readln(hora);
    end;

    write('Ingrese los minutos (0 - 59):');
    readln(minutos);

    while minutos >= 60 do
    begin
        write('Ingresó mal los minutos. Por favor vuelva a ingresar los minutos: ');
        readln(minutos);
    end;

    horario := hora * 100 + minutos;

    // i := busqueda_secuencial(horario, cantidad, vec_hora);
    i := busqueda_binaria(horario, cantidad, vec_hora);

    if i > cantidad then
        writeln('No se encontró el registro para ese horario')
    else
    begin
        writeln('La temperatura medida fue ', vec_temp[i]:0:2, '°C');
        writeln('La humedad medida fue ', vec_hum[i]:0:2, '%');
    end;
end;

procedure mostrar_menu();

begin
    writeln('Elija una opción:');
    writeln('     1) Mostrar los datos cargados en un tabla');
    writeln('     2) Mostrar las mediciones para un horario');
    writeln('     s) Salir');
end;

begin
    cargar_datos(g_cantidad, g_vec_hora, g_vec_temp, g_vec_hum);

    mostrar_menu();
    readln(g_opcion);
    while upcase(g_opcion) <> 'S' do
    begin
        case g_opcion of
            '1': mostrar_en_tabla(g_cantidad, g_vec_hora, g_vec_temp, g_vec_hum);
            '2': buscar_horario(g_cantidad, g_vec_hora, g_vec_temp, g_vec_hum);
        else
            writeln('Opción no reconocida');
        end;

        mostrar_menu();
        readln(g_opcion);
    end;

end.