program ristorante (input, output);

 

{Supporta l'utente nella scelta di un ristorante. La lista dei ristoranti e'

 memorizzata in un array di record e non e' modificabile da

 input. I ristoranti sono classificati in base a 4 caratteristiche:

 

 prezzo,

 cucina,

 servizio,

 locale

 

 il prezzo e' specificato in migliaia di Lire. Le altre 3

 caratteristiche sono specificate attraverso i seguenti giudizi:

 insufficiente, sufficiente, buono, ottimo.

 

 Il programma permette due tipi di selezione:

 1. stampa la lista dei ristoranti che soddisfano tutti i requisiti

 inseriti

 2. trova il ristorante piu' economico fra quelli che soddisfano un

 criterio inserito in input

 }

 

const nrist = 5; {numero dei ristoranti}

 

type giudizio = (insufficiente, sufficiente, buono, ottimo);

   reclist    = record

                   prezzo                   : integer;

                   cucina, servizio, locale : giudizio;

                   scelto                   : boolean

                end;                       

             

listarist = array [1 .. nrist] of reclist;

 

var

   ristoranti        : listarist;

   tiposel, i, conta : integer;

   iniziale          : char;

   soglia            : giudizio;

                    

{dichiarazione procedure}

  

procedure converti(var criterio : giudizio; ch:char);

 

{

 converte il valore di tipo char in un valore del tipo enumerato giudizio

 associando alla variabile criterio il valore il cui identificatore

 inizia col valore di ch

 }

 

begin

   case ch of

     'i' : criterio := insufficiente;

     's' : criterio := sufficiente;

     'b' : criterio := buono;

     'o' : criterio := ottimo

   end { case }

end;

 

procedure listaognicriterio(var lista : listarist);

 

{

 chiede di inserire i requisiti del ristorante ricercato e

 marca tutti i ristoranti (i.e., assegna il valore true al campo

 scelto) per cui tutti i requisiti sono soddisfatti

 }

var prezzorichiesto, i                                 : integer;

   cucinarichiesta, serviziorichiesto, localerichiesto : giudizio;

   ch                                                  : char;

                                                      

begin

  

   {chiede all'utente di inserire i giudizi di riferimento}

   {e' necessario convertire il valore letto di tipo char in un valore

    del tipo enumerato giudizio}

  

   writeln('prezzo ? (espresso in migliaia di lire)');

   readln(prezzorichiesto);

  

   repeat

      writeln('cucina? [i, s, b, o]');

      readln(ch)

   until ch in ['i', 's', 'b', 'o'];

   converti(cucinarichiesta, ch);

  

   repeat

      writeln('servizio? [i, s, b, o]');

      readln(ch)

   until ch in ['i', 's', 'b', 'o'];

   converti(serviziorichiesto, ch);

 

   repeat

      writeln('locale? [i, s, b, o]');

      readln(ch)

   until ch in ['i', 's', 'b', 'o'];

   converti(localerichiesto, ch);

 

   {verifica la condizione: se true marca il ristorante}

 

   for i := 1 to nrist

      do if (lista[i].prezzo <= prezzorichiesto) and

         (lista[i].cucina >= cucinarichiesta) and

         (lista[i].servizio >= serviziorichiesto) and

         (lista[i].locale >= localerichiesto)

         then lista[i].scelto := true;

  

end; {listaognicriterio}

 

procedure migliore (var lista : listarist; soglia : giudizio);

 

{chiede di inserire una soglia minima di giudizio per la cucina e

 marca il campo scelto del ristorante col prezzo piu' basso fra quelli

 che soddisfano la soglia inserita}

 

var   j, indmin, prezzomin:integer;

  

begin

  

   prezzomin := maxint;

   indmin := 0;

   for j := 1 to nrist

      do if (lista[j].prezzo < prezzomin) and (lista[j].cucina >= soglia)

         then begin

            prezzomin := lista[j].prezzo;

            indmin := j

         end;

   if indmin <> 0

      then lista[indmin].scelto := true

     

end;

{main}

 

begin

 

   {scrittura della lista}

   ristoranti [1].prezzo := 30;

   ristoranti [1].cucina := insufficiente;

   ristoranti [1].servizio := ottimo;

   ristoranti [1].locale := sufficiente;

   ristoranti [1].scelto := false;

  

   ristoranti [2].prezzo := 20;

   ristoranti [2].cucina := sufficiente;

   ristoranti [2].servizio := insufficiente;

   ristoranti [2].locale := buono;

   ristoranti [2].scelto := false;

 

   ristoranti [3].prezzo := 50;

   ristoranti [3].cucina := ottimo;

   ristoranti [3].servizio := sufficiente;

   ristoranti [3].locale := buono;

   ristoranti [3].scelto := false;

  

   ristoranti [4].prezzo := 30;

   ristoranti [4].cucina := sufficiente;

   ristoranti [4].servizio := sufficiente;

   ristoranti [4].locale := sufficiente;

   ristoranti [4].scelto := false;

  

   ristoranti [5].prezzo := 25;

   ristoranti [5].cucina := buono;

   ristoranti [5].servizio := buono;

   ristoranti [5].locale := insufficiente;

   ristoranti [5].scelto := false;

  

   {chiede all'utente il tipo di selezione: 1 = soddisfacimento di

    tutti i requisiti; 2 = trova il piu' economico che soddisfa un certo

    requisito}

 

   writeln ('Inserire il tipo di selezione: 1 = tutti i criteri; 2 = un criterio');

   readln(tiposel);

  

   case tiposel of

    

     1 :

         begin

            listaognicriterio(ristoranti);

            conta := 0;

            for i := 1 to nrist

               do

               if ristoranti [i].scelto

                  then begin

                     conta := conta + 1;

                     writeln('ristorante ', i)

                  end;

           if conta = 0 then writeln('nessun ristorante trovato');

         end;

    

     2 :

         begin

            repeat

               writeln('scegliere una soglia minima per la cucina [i, s, b, o] ');

               readln(iniziale)

            until (iniziale in ['i', 's','b','o']);

            converti (soglia, iniziale);

           

            migliore (ristoranti, soglia);

           

           

              i := 1;

            repeat

               if ristoranti [i].scelto

                  then writeln('ristorante ', i);

               i := i +1

            until (ristoranti [i-1].scelto) or (i > nrist);

            if not ristoranti [i-1].scelto

               then writeln ('nessun ristorante soddisfa la soglia richiesta')

         end  

    

   end

end.