Newsgroup: it.comp.lang.c
Titolo: Lupo capra e cavolo!

salve, super esperti online!
Voi come impostereste il problema come da oggetto?
Nel senso: realizzare un programma che fornisca la soluzione .
E' l'arcinoto problema del contadino deve attraversare un fiume con
una barca, sulla quale può portare, oltre a sè, un oggetto solo: o
lupo, o capra o cavolo.Se porta  il cavolo, mentre traghetta,sulla
sponda del fiume  il lupo mangerà la capra....etc etc
vediamo che esce fuori!! :-)

?_?
-- 
 Ciao, Bianco.
 Reply to luca.bianco (at) 
tiscalinet.it

 ?_?
non c'è una spiegazione a ciò...
:o)
--
ciao
..::[xaero]::..

prima porta la capra sulla riva opposta, poi torna e prende il cavolo, lo
porta sull'altra riva e prende la capra e la porta sulla riva iniziale. qui
prende il lupo e lo porta dall'altra. poi torna e prende la capra. MITICO!


wrote:
Quindi il tuo programma sarebbe il seguente ?
  #include <stdio.h>
  int main(void)
  {
    printf("prima porta la capra sulla riva opposta, poi "
           "torna e prende il cavolo, lo porta sull'altra "
           "riva e prende la capra e la porta sulla riva "
           "iniziale. qui prende il lupo e lo porta "
           "dall'altra. poi torna e prende la capra.\n"
           "MITICO!\n");
    return 0;
  }
Sicuramente compatto. Ma se fossi io un insegnante
prenderesti 2/10 per questo esercizio. ;)
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

Voi come impostereste il problema come da oggetto?
...
Nel seguito c'e' una possibile soluzione. Non ho provato
a renderla efficiente o compatta puntando piuttosto sulla
leggibilita'. In problemi di ricerca piu' complessi
(es. scacchi) senza una serie di accorgimenti specifici
del problema e' difficile ottenere qualcosa di ragionevole.
L'output del programma e' il seguente:
  Trovata una soluzione!
  ==(CAPRA)=>
  <=()==
  ==(LUPO)=>
  <=(CAPRA)==
  ==(CAVOLO)=>
  <=()==
  ==(CAPRA)=>
  Soluzione trovata a livello 7
------ INIZIO SORGENTE C ------
#include <stdio.h>
/* Maschere di bit per i vari personaggi */
#define LUPO   0x0001
#define CAPRA  0x0002
#define CAVOLO 0x0004
/* Personaggi presenti sulle due rive */
int riva[2];
/* Riva su cui si trova al momento il contadino */
int contadino;
/*
 * Restituisce 1 se il problema e' risolto
 * ovvero se sulla riva 1 si trovano contemporaneamente
 * il lupo, la capra e il cavolo
 */
int Fatto(void)
{
  return riva[1]==(LUPO|CAPRA|CAVOLO);
}
/*
 * Restituisce 1 se e' successo un disastro, ovvero
 * se sulla riva dove non si trova il contadino
 * rimangono lupo e capra oppure capra e cavolo
 */
int Tragedia(void)
{
  int situazione=riva[1-contadino];
  return ((situazione&LUPO)&&(situazione&CAPRA))   ||
         ((situazione&CAPRA)&&(situazione&CAVOLO));
}
/*
 * Registrazione di tutte le mosse fatte
 */
#define MAX_MOSSE 100
/* Numero mosse giocate */
int n_mosse;
/* Passeggero trasbordato alla mossa n-esima */
int Mosse[MAX_MOSSE];
/*
 * Restituisce un nome passeggero in chiaro
 */
const char *StrMossa(int pass)
{
  if (pass==LUPO)   return "LUPO";
  if (pass==CAPRA)  return "CAPRA";
  if (pass==CAVOLO) return "CAVOLO";
  return "";
}
/*
 * Stampa le mosse giocate sino ad ora
 */
void StampaSoluzione(void)
{
  int i,c;
  c=0; /* Lato contadino */
  for (i=0; i<n_mosse; i++,c=1-c)
  {
    if (c==0)
    {
      printf("==(%s)=>\n",StrMossa(Mosse[i]));
    }
    else
    {
      printf("<=(%s)==\n",StrMossa(Mosse[i]));
    }
  }
}
/*
 * Gioca una mossa: il contadino porta il passeggero
 * indicato da una parte all'altra del fiume
 */
void Play(int passeggero)
{
  /* Salva la mossa fatta */
  Mosse[n_mosse++]=passeggero;
 
  /* Toglie il passeggero dalla riva di partenza */
  riva[contadino]&=~passeggero;
  /* Passa dall'altra parte */
  contadino=1-contadino;
  /* Mette il passeggero sulla riva di arrivo */
  riva[contadino]|=passeggero;
}
/*
 * Torna indietro di una mossa
 */
void Undo(void)
{
  int passeggero=Mosse[--n_mosse];
  riva[contadino]&=~passeggero;
  contadino=1-contadino;
  riva[contadino]|=passeggero;
}
/*
 * Prova a risolvere il problema facendo al
 * massimo "level" mosse
 */
int Try(int level)
{
  /* Guarda se e' successo un disastro */
  if (Tragedia())
  {
    return 0;
  }
 
  /* Guarda se abbiamo finito */
  if (Fatto())
  {
    printf("Trovata una soluzione!\n");
    StampaSoluzione();
    return 1;
  }
 
  /* Guarda se e' possibile fare altre mosse */
  if (level==0)
    return 0;
  /* Prova le possibili mosse */
 
  if (riva[contadino]&LUPO)
  {
    /* Prova a portare il lupo */
    Play(LUPO); 
    if (Try(level-1)) return 1;
    Undo();
  }
 
  if (riva[contadino]&CAPRA)
  {
    /* Prova a portare la capra */
    Play(CAPRA);
    if (Try(level-1)) return 1;
    Undo();
  }
 
  if (riva[contadino]&CAVOLO)
  {
    /* Prova a portare cavolo */
    Play(CAVOLO);
    if (Try(level-1)) return 1;
    Undo();
  }
 
  /* Prova un viaggio a vuoto */
  Play(0);
  if (Try(level-1)) return 1;
  Undo();
  return 0;
}
int main(void)
{
  int l=0;
  contadino=0;
  riva[0]=LUPO|CAPRA|CAVOLO;
  while (l<MAX_MOSSE && !Try(l))
    l++;
  if (l==MAX_MOSSE)
  {
    printf("Non e' stata trovata soluzione\n");
  }
  else
  {
    printf("Soluzione trovata a livello %i\n",l);
  }
  return 0;
}
------ FINE SORGENTE C ------
HTH
