Newsgroup: it.comp.programmare
Titolo: Semplice esercizio prolog

Ciao a tutti.
Ho un semplice esercizio in prolog da realizzare ma non ho idea di
come farlo.
Non necessita di interfaccia grafica. Devono essere poche righe di
codice (credo servano anche meno di 10 righe di codice)...
Il testo e':
Si costruisca una funzione in PROLOG che ha come argomento una
generica sequenza di elementi atomici e verifichi se tale lista gode
della proprieta' di essere palindroma.
Esempi di sequenze palindrome sono:( r a d a r ) e ( a n n a ).
In caso la lista pasata non sia palindroma, si costruisca una lista i
cui elementi sono le coppie di atomi che NON la rendono palindroma. Ad
esempio, la sequenza "ALBERO" ovviamente, non è palindoma a causa
delle seguenti coppie:
"A O" "L R" "B E".
La formattazione del testo in output e' a mia libera discrezione.
Se qualcuno mi potesse aiutare mi farebbe un ENORME favore. Grazie in
anticipo!

 wrote in message
news:3d5f8053.03011...@posting.google.com...

Ciao,
non ricordo piu' il prolog, che studiai all'universita' anni fa e poi non ho
piu' usato.
Ma a prescindere dal linguaggio di programmazione il tuo problema del
palindroma si puo' spiegare con un semplice ciclo :
- sia N la lunghezza della tua stringa (sequenza di elementi atomici!)
- setta un flag (una variabile) PALINDROMA a vero (oppure a 1).
- sia I un indice che tu inizializzi a 0 (dipende da come il prolog tratta
le stringhe)
- fai un ciclo che incrementa I e lo fa arrivare fino a N/2
- ad ogni passo controlli che l'elemento atomico I (ma come cacchio si fa a
chiamare cosi' un carattere?), e' uguale all'elemento atomico N-I
- se trovi un confronto che ti dice che sono diversi setti il flag
PALINDROMA a falso (oppure a 0).
Alla fine testi il flag e a seconda della risposta dai in output
"PALINDROMA" o "Ritenta e sarai piu' fortunato".
Maurus

 "A O" "L R" "B E".
//---------------------------------------------------
//	restituisce la lista delle coppie "errate"
//	se la parola non è palindroma, una lista vuota
//	se lo è
nonpalindroma([],[]).
nonpalindroma([A],[]):- atom(A).
nonpalindroma([A|Input],Output):- 	 
coda(Input,In,A),nonpalindroma(In,Output).
nonpalindroma([A|Input],Output):- 	 
coda(Input,In,_),nonpalindroma(Input,[[A|_]|Output]).
//-----------------------------------------------------
//	restituisce l'ultimo elemento di una lista (A)
//	e la lista privata del suo elemento finale (In)
coda([_],[],_):- atom(_).
coda([_|Input],[_|In],A):- coda(Input,In,A).
Il programma DOVREBBE funzionare, SE mi ricordo bene il
linguaggio e SE l'implementazione che usi ammette questa
sintassi... cavolo erano anni che non vedevo più programmi
Prolog in giro!
Grazie di avermi dato l'occasione di rispolverarlo...
è un gran bel linguaggio! :-)

 le stringhe)
No, no, sei fuori strada... non puoi usare il Prolog
come fosse Fortran :-)
Non puoi prescindere dal linguaggio, perchè l'algoritmo che illustri è
pensato per un linguaggio IMPERATIVO, mentre il Prolog NON LO E'...
scrivere una cosa come dici tu in Prolog è impossibile.
Per dirne una in Prolog le variabili non si "inizializzano"...
"inizializzare" è un concetto che non esiste proprio :-)
E' QUESTA la difficoltà... devi cambiare completamente il tuo modo
di ragionare! Il Prolog è un linguaggio alieno :-))

 č un gran bel linguaggio! :-)
Capperi!
Non me lo ricordavo cosi' alieno...
Sono passati anni e mi sono C-izzato.
Ma ci sono applicazioni pratiche per utilizzare Prolog o lo si usa solo in
ambiti universitari?
Maurus
p.s.
Ebbene si' maledetto Carter, mi hai fregato anche stavolta!

 ambiti universitari?
Ecco... praticamente solo nelle università :-)
Nel mondo dello sviluppo software lo si usa (chi lo usa) più
come linguaggio per prototipazione rapida di applicazioni che
come mezzo per creare programmi funzionanti. Infatti uno dei
vantaggi del Prolog è quello di essere estremamente "espressivo",
cioè di sbrigare con poche istruzioni compiti che con i linguaggi
imperativi devono essere descritti per esteso con parecchie righe
di codice. :-)
Purtroppo però manca in modo clamoroso di efficienza, oltre come
detto a richiedere un modo di pensare completamente nuovo (e
particolarmente ostico proprio per i professionisti, abituati
da anni a pensare in modo procedurale...) quindi tempi di
apprendimento lunghi e molta fatica proprio da parte di chi lo
dovrebbe usare di più :-(
Qualcosa si muove, a quel che so: ci lavorano molto in Australia,
con implementazioni innovative come il Mercury (un ibrido C/Prolog
sulla carta molto interessante) ma non prevedo inversioni di tendenza
a breve... sob sob :-(

 è un gran bel linguaggio! :-)
Il Prolog è veramente alieno, programmare in prolog è un'esperienza quasi
mistica ;)
A scuola, per metodi, feci un interprete basic scritto in prolog in circa
3.5 kb di codice (compreso di funzioni ricorsive e variabili locali).
Per quanto riguarda il problema proposto dovrebbe essere sufficiente fare:
palindroma(Parola):-
    reverse(Parola,Parola).