Newsgroup: it.comp.lang.c++
Titolo: Re : Algoritmo

Non fa niente ! L'ho risolto da solo! Chi fa da sè fa per tre ! Soprattutto
in questo NG dove l'ignoranza dilaga !

 in questo NG dove l'ignoranza dilaga !
Piu' che l'ignoranza la pigrizia, mi pare.
Ciao,
Nicola

in questo NG dove l'ignoranza dilaga !
ROTFL ! 
--
CyberWalkie - walkietalkie(at)
libero.it

 in questo NG dove l'ignoranza dilaga !
Se proprio vuoi saperlo, dall'alto della mia ignoranza, quando ho visto il tuo
messaggio ho pensato:
1) ecco un'altro che vuole la pappa pronta.
2) e probabilmente ecco un altro professore che capisce poco.
Poi, dato che il pensiero 1 era piu' una costatazione che una supposizione, per
curiosita' ho verificato il pensiero 2.
Ovvero ho letto il codice proposto per l'esercizio.
E se vuoi saperlo mi ha fatto pensare.
Non perche' sia difficile o sbagliato (al contrario, chi lo ha proposto e'
tutt'altro che stupido: mi sono ricreduto sulla 2) ma per il tipo di
ragionamento che sottintende. E ho "perso" qualche minuto in meditazione
cercando di ricordare da quanto tempo non vedevo un esercizio sulla ricorsione
da svolgersi in un linguaggio strutturato che era, giustamente, proposto con una
struttura ricorsiva.
E anche da quanto tempo non vedevo un qualcuno che usasse un linguaggio
strutturato pur mantenendo un "modus pensandi" ricorsivo (o matematico).
In altre parole mi sono fermato a riflettere sull'eleganza e sui vantaggi delle
due possibili implementazioni della classica struttura "(single) linked list".
Quella risultante dal pensiero strutturato (e spesso anche di quello a oggetti)
tipico di chi ha imparato a programmare in C/C++/Pascal/Fortran etc. e quella
matematico/ricorsiva che viene tremendamente naturale a chi lavora in Lisp o a
chi ha imparato a "ragionare" in termini matematici prima che
algoritmico/strutturati.
Tempo fa dissi che per formare la mente e' utile imparare parecchi linguaggi. E
soprattutto parecchi paradigmi (per esempio imparare non solo linguaggi come il
Pascal o il C ma anche, almeno in parte, linguaggi come il Lisp o linguaggi come
il Prolog).
Ecco un esempio di quello che intendevo. Quella che potremmo chiamare una "Mente
Strutturata" (Pascal, C, C++ etc.) troverà naturale la lista lincata
implementata cosi':
struct Data {
    // ...
};
struct Node {
    Data d;
    Node *next;
};
struct List {
    Node *first;
};
List aList;
Quella che potremmo chiamare una "Mente Ricorsiva" (Lisp etc.) troverà invece
naturale questo:
struct Data {
    // ...
};
struct List {
    Data d;
    List *tail;
};
List *aList=0;
Naturalmente ho rappresentato solo la strutturazione dei dati. Il vero
divertimento sta nella differente eleganza (sono tutte e due eleganti, ma in
modo diverso) delle due strutturazioni. E il bello sta nelle diverse (sebbene
simili) implementazioni dei vari algoritmi (o se preferisci operazioni/metodi o
che dir si voglia).
Per esempio defire le operazioni necessarie per estrarre un elemento dalla
lista.
L'accesso ai dati e' banale per entrambe i casi:
Data GetData(Node*p)
{
    assert(p!=0);
    return p->d;
}
ovvero
Data GetData(List*l)
{
    assert(l!=0);
    return l->d;
}
Ma l'accesso ad un elemento qualunque della lista (per default il primo) e' un
altro discorso. Una "Mente Strutturata" farà qualche cosa del genere:
// il primo nodo è 0
// ritorna il primo nodo ( aka GetFirst() )
// oppure l'ennesimo ( aka GetN(n) )
Node* GetNodeN(List*l, int n=0)
{
    assert(l!=0);
    assert(n>=0);
    Node *p=l->first;
    for ( int i=0; i<n; ++i, p=p->next )
        assert(p!=0);
    return p;
}
Persino per lavorare con la struttura ricorsiva farà qualche cosa del tipo:
// il primo elemento e' al nodo 0
// ritorna la sottolista che inizia con il nodo N
// per default ritorna la lista stessa
List* GetListN(List*l, int n)
{
    assert( n==0 || l!=0 );
    assert( n>=0 );
    List *p=l;
    for ( int i=0; i<n; ++i, p=p->tail )
        assert(p!=0);
    return p;
}
Naturalmente una "Mente Ricorsiva" troverà poco naturale questo codice perche'
penserà alla cosa in termini differenti:
// la sottolista stessa e' 0
// ritorna la sottolista stessa ( aka Head() )
// oppure l'ennesima ( aka TailN(n) )
List* GetTailN(List*l, int n)
{
    assert( n>=0 );
    if ( n==0 )
        return l;
    assert( l!=0 );
    return GetTailN(l->tail, n-1)
}
Curioso come il commento che precede la funzione "GetListN" rispecchi come la
"mente Strutturata" ha 'forzato' la sua interpretazione di una struttura
ricorsiva. E' chiaro che la struttura e' ricorsiva. Ma non e' banale capire che
lista sotolista sono la stessa cosa. Una lista puo' avere almeno un elemento
oppure essere vuota. Una sottolista ha sempre un elemento, alrimenti non esiste.
E' la stessa cosa. Ma il ragionamento "Strutturato" parla di liste che
contengono elementi. Ergo viene da dire "il primo elemento" e "la sottolista che
inizia con l'ennesimo elemento".
Non stupisce che il ragionamento "Ricorsivo" non sia a suo agio con questa
visione. Ricorsivamente una lista/sottolista o esiste o no. Non c'e' l'elemento
N nel nodo N. C'e' la lista/sottolista N. E se questa esiste c'e' il suo primo
elemento. Il commento a "GetTailN" e' infatti praticamente lo stesso di
"GetNodeN". Solo in visione ricorsiva.
Quindi, caro Xanten, laddove tu vedevi un problema di implementazione di codice,
noi ignoranti vediamo la possibilita' di ragionare sulle varie alternative non
solo alla soluzione del problema proposto (circa 75 secondi di ragionamento) ma
alle varie alternative della classe di problemi legati ad una struttura dati e
alle varie possibili rappresentazioni della stessa nonche' al fatto che ciascuna
ha una sua eleganza intrinseca, i suoi benefici ed i suoi svantaggi. E
naturalmente a quali sono le situazioni in cui una o l'altra sono "migliori". E
al fatto che il risolvere il problema specifico e' importante ma non
sufficiente. Il passo successivo consiste nell'allenarsi a riuscire a vedere con
la stessa naturalezza tutte e due le alternative (ed eventuali altre) senza
pregiudizi legati al modo in cui siamo portati a ragionare dal linguaggio
specifico in uso.
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

E se vuoi saperlo mi ha fatto pensare.
Anche io sono rimasto molto colpito dall'approccio fornito:
personalmente non disdegno affatto la ricorsione (sia nelle
strutture dati che negli algoritmi) ma per l'implementazione
di una lista non l'ho trovato assolutamente "naturale" anche
se, mi vergono a dirlo, in passato avevo addirittura scritto
un interprete di un linguaggio molto molto simile al LISP.
Quindi mi sono salvato il messaggio come promemoria :-) ... forse
ho mandato in soffitta quel modo di ragionare. Quelle sono
comunque frecce che e' comodo tenere a portata di mano.
Riguardo all'alunno cosi' pigro da girare semplicemente il testo
degli esercizi su internet sperando che qualcuno gli faccia i
compiti non so proprio cosa dire.
Forse varrebbe la pena "aiutare" questa gente facendogli gli esercizi
da zero, in modo da tirare su dei deficenti e avere meno competizione
vera nel settore. Pero' mi sembra di essere cattivo quando penso
queste cose... forse e' piu' umano farlo sbranare da una muta di
farfalle da combattimento allenate da quell'austro-siculo che
sappiamo :)
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 vera nel settore.
No, per carita' che poi si laureano/diplomano e quindi entrano nel mondo
del lavoro. Per qualche motivo strano le ditte dove ho lavorato hanno
sempre avuto la tendenza a piazzare i "casi umani" nei progetti
coordinati da me :-(
Ciao,
Nicola

 sappiamo :)
LOL


 sappiamo :)
Premesso che essendo mancato per molto tempo, non sono al corrente
della attuale situazione del NG, mi pare di capire che la situazione
sia
poco cambiata e che ci sono ancora persone che cercano di farsi
risolvere gli esercizi.
In questi casi la mia scelta e` quella di indicare la via (dipende da
come viene fatta la richiesta), ma mai di fornire la soluzione.
Detto cio... chi sarebbe l'austro-siculo?  :)
Paolo
--
Paolo Marotta
Home: 
http://web.tiscalinet.it/paolo_marotta
Master's Level in C++ Certified by Brainbench
http://www.brainbench.com/transcript.jsp?pid=2440649

 coordinati da me :-(
ROFL
Ciao
Alessandro

 Detto cio... chi sarebbe l'austro-siculo?  :)
Ti arriva in e-mail fra un attimo.



Posso saperlo anch'io?
Ciao
Alessandro Bosetti

 Posso saperlo anch'io?
Mi associo!
Ciao,
Nicola