practica 9 ejercicio 10 BETA, Pascal

Language: Layout:

program HelloWorld;
{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
CONST - Define las constantes para usar en tiempo de compilacion}
const
    platos = 100;
    FIN = 'fin';
{-----------------------------------------------------------------------------------------------------------------------}

{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
TYPE - Define los tipos creados por el usuario para usar en tiempo 
de compilacion}
type
    // rango de platos
    rangoPlatos = 1 .. platos;
    
    // tipo nombre
    Tnombre = string[15];
    
    // registro de clientes
    Tcliente = record
            nombre : Tnombre;
            apellido : Tnombre;
            codigo : integer;
            telefono : integer;
            domicilio : Tnombre;
    end;
    
    // registro de platos
    Tplato = record
            nombre : Tnombre;
            stock : integer;
    end;
    
    // registro de pedidos
    Tpedido = record
            codigo : integer; // codigo del cliente
            cantidad : integer; // stock
            plato : rangoPlatos; // codigo del plato
    end;
    
    
    // vector de platos
    Tvector = array [rangoPlatos] of Tplato;
    
    // lista de clientes
    Tlista= ^nodo;
    nodo = record
            datos : Tcliente;
            sig : Tlista;
    end;
{-----------------------------------------------------------------------------------------------------------------------}

{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
VARIABLES GLOBALES - Define variables que se podran usar por todos los modulos
de ser necesarias}
//var
{-----------------------------------------------------------------------------------------------------------------------}

// lista
{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
}
procedure leerCliente(var c : Tcliente);
begin
    readln(c.nombre);
    if (c.nombre <> FIN) then begin                   {aca solo se debe ingresar nombre,apellido y domicilio}
        readln(c.apellido);
        c.codigo := random(1000);
        c.telefono := random(9999);
        readln(c.domicilio);
    end;
end;
{-----------------------------------------------------------------
}
procedure agregarCliente(var l : Tlista; c : Tcliente);
var nue : Tlista;
begin
        new(nue);
        nue^.datos := c;
        nue^.sig := l;
        l := nue;
end;
{-----------------------------------------------------------------
}
procedure cargarLista(var l : Tlista);
var
    c : Tcliente;
begin
    leerCliente(c);
    while c.nombre <> FIN do begin
        agregarCliente(l,c);
        leerCliente(c);   
    end;
end;
{-----------------------------------------------------------------
}
procedure imprimirCliente(c : Tcliente);
begin
    writeln('nombre :',c.nombre);
    writeln('apellido: ',c.apellido);
    writeln('codigo: ',c.codigo);
    writeln('telefono: ',c.telefono);
    writeln('domicilio: ',c.domicilio);
end;
{-----------------------------------------------------------------
}
procedure imprimirLista(l : Tlista);
begin
    while l <> nil do begin
        imprimirCliente(l^.datos);
        l := l^.sig;
    end;
end;
{-----------------------------------------------------------------
}
procedure liberarLista(var l : Tlista);
var
    aux : Tlista;
begin
    while l <> nil do begin
        aux := l^.sig;
        dispose(l);
        l := aux;
    end;
end;
{-----------------------------------------------------------------------------------------------------------------------}

// vector
{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
}
procedure cargarVector(var v : Tvector);
var
    i : rangoPlatos;
begin
    for i := 1 to platos do begin
        readln(v[i].nombre);
        v[i].stock := random(14);
    end;
end;
{-----------------------------------------------------------------
}
procedure imprimirPlato(p : Tplato);
begin
    writeln('nombre :' , p.nombre);
    writeln('stock disponible: ', p.stock);
end;
{-----------------------------------------------------------------
}
procedure imprimirVector(v : Tvector);
var
    i : rangoPlatos;
begin
    writeln('---------------------');
    for i:=1 to platos  do begin
        imprimirPlato(v[i]);
        writeln('---------------------');
    end;
end;
{-----------------------------------------------------------------------------------------------------------------------}

// agregado
{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
}
procedure espacio;
begin
    writeln;writeln;writeln;writeln;
    writeln('--------------------------------------------------------------------------');
end;
{-----------------------------------------------------------------------------------------------------------------------}

// realizar pedidos
{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
}
procedure leerPedido(var p : Tpedido);
begin
    readln(p.codigo);// codigo de cliente
    if p.codigo <> -1 then begin
        p.cantidad:= random(14)+1 ;//stock
        p.plato := random(platos)+1;//codigo de plato
    end;
    
end;
{-----------------------------------------------------------------
}
procedure pedido(p : Tpedido; l : Tlista;var v : Tvector);
begin
    while (l <> nil)and(l^.datos.codigo <> p.codigo) do l := l^.sig;
    if l <> nil then begin
            if (p.cantidad <= v[p.plato].stock) then begin
                    v[p.plato].stock:=v[p.plato].stock-p.cantidad;
            end else writeln('no hay suficiente stock disponible');
    end else writeln('el cliente no está en la lista');
end;

{-----------------------------------------------------------------
}
procedure cargarPedidos( l : Tlista; var v : Tvector);
var
    p : Tpedido;
begin
    leerPedido(p);
    while p.codigo <> -1 do begin
        pedido(p,l,v);
        leerPedido(p);
    end;
end;
{-----------------------------------------------------------------------------------------------------------------------}

// informar
{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
}

{-----------------------------------------------------------------------------------------------------------------------}

{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
PROGRAMA PRINCIPAL}
var
    l : Tlista;
    v : Tvector;
begin
    
    
end.
{-----------------------------------------------------------------------------------------------------------------------}

Show compiler warnings [ + ] Show input
Compilation time: 0.22 sec, absolute running time: 0.16 sec, cpu time: 0.01 sec, memory peak: 5 Mb, absolute service time: 0,54 sec