{"id":40208,"date":"2020-02-01T06:04:35","date_gmt":"2020-02-01T03:04:35","guid":{"rendered":"https:\/\/prohoster.info\/blog\/blog_prohoster\/kak-nauchit-preodolevat-trudnosti-a-zaodno-i-pisat-czikly"},"modified":"2020-02-01T06:04:35","modified_gmt":"2020-02-01T03:04:35","slug":"kak-nauchit-preodolevat-trudnosti-a-zaodno-i-pisat-czikly","status":"publish","type":"post","link":"https:\/\/prohoster.info\/it\/blog\/kak-nauchit-preodolevat-trudnosti-a-zaodno-i-pisat-czikly","title":{"rendered":"Come insegnare a superare le difficolt\u00e0 e, allo stesso tempo, a scrivere cicli","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"

Sebbene si tratti di un argomento basilare, questo articolo \u00e8 scritto per professionisti esperti. L'obiettivo \u00e8 mostrare quali fraintendimenti hanno i principianti nella programmazione. Per i programmatori praticanti, questi problemi sono gi\u00e0 stati risolti da tempo, dimenticati o addirittura mai notati. L'articolo potrebbe rivelarsi utile, nel caso vi capiti di dover aiutare qualcuno su questo argomento. Vengono tracciate parallelismi con materiali di vari libri di programmazione di autori come Schildt, Stroustrup e Okulov.<\/p>\n

L'argomento sui cicli \u00e8 stato scelto perch\u00e9 molti abbandonano proprio durante l'apprendimento della programmazione.<\/p>\n

Questa metodologia \u00e8 progettata per studenti meno forti. Di solito, gli studenti pi\u00f9 capaci non si bloccano su questo tema e non \u00e8 necessario elaborare metodologie particolari per loro. L'obiettivo secondario dell'articolo \u00e8 quello di rendere questa metodologia applicabile a tutti gli studenti e a tutti gli insegnanti, invece di essere limitata a \u00abfunziona per tutti gli studenti, ma solo con un insegnante\u00bb. Non pretendo di essere assolutamente originale. Se gi\u00e0 utilizzate una metodologia simile per insegnare questo argomento, vi prego di comunicarmi in cosa il vostro approccio differisce. Se decidete di applicarla, raccontatemi come \u00e8 andata. Se una metodologia simile \u00e8 descritta in un libro, vi prego di indicare il titolo.<\/p>\n

<\/a><\/noindex>
\nHo sviluppato questa metodologia per 4 anni, lavorando individualmente con studenti di vari livelli. In totale, ho avuto circa cinquanta studenti e duemila ore di lezione. Inizialmente, gli studenti si bloccavano sempre su questo tema e se ne andavano. Dopo ogni studente, la metodologia e i materiali venivano corretti. Nell'ultimo anno, gli studenti non si bloccano pi\u00f9 su questo tema, quindi ho deciso di condividere le mie esperienze.<\/p>\n

Perch\u00e9 scrivere tante parole? I cicli sono cos\u00ec elementari!<\/h4>\n

\nCome ho gi\u00e0 detto, per i programmatori praticanti e per gli studenti pi\u00f9 forti, la difficolt\u00e0 del concetto di cicli pu\u00f2 essere sottovalutata. Ad esempio, si pu\u00f2 tenere una lunga conferenza, vedere teste annuire e occhi brillanti. Ma nel tentativo di risolvere un qualsiasi problema, ci si blocca e si incontrano problemi inspiegabili. Dopo la conferenza, gli studenti probabilmente hanno solo una comprensione parziale. La situazione \u00e8 aggravata dal fatto che gli studenti non riescono a esprimere qual \u00e8 esattamente il loro fraintendimento.
\nUn giorno ho realizzato che gli studenti percepiscono i miei esempi come geroglifici. Cio\u00e8 come segmenti di testo indecifrabili, nei quali bisogna scrivere una sorta di lettera \"magica\" affinch\u00e9 tutto funzioni.
\nA volte notavo che gli studenti pensano che per risolvere un compito specifico sia necessaria un'altra<\/i> costruzione che non ho ancora menzionato. Anche se per risolvere la questione era sufficiente modificare un po' l'esempio.<\/p>\n

Quindi sono arrivato all'idea che l'attenzione principale deve essere rivolta non alla sintassi delle espressioni, ma all'idea di rifattorizzare il codice ripetitivo attraverso i cicli. Non appena gli studenti padroneggiano questa idea, qualsiasi sintassi viene appresa grazie a piccoli esercizi.<\/p>\n

A chi e perch\u00e9 insegno<\/h4>\n

\nPoich\u00e9 non ci sono esami di ammissione, in aula possono esserci sia studenti forti che molto deboli. Potete leggere di pi\u00f9 sui miei studenti nell'articolo Ritratto degli ascoltatori dei corsi serali<\/a><\/noindex>
\nIl mio obiettivo era quello di far apprendere la programmazione a chiunque desiderasse farlo.
\nLe mie lezioni si svolgono individualmente e lo studente paga di tasca propria per ogni sessione. Sembrerebbe che gli studenti cerchino di ottimizzare le spese e richiedano il minimo indispensabile. Tuttavia, le persone partecipano a lezioni in presenza con un insegnante non solo per le conoscenze, ma per la sicurezza di aver assimilato ci\u00f2 che \u00e8 stato insegnato, per la sensazione di progresso e per l'approvazione dell'esperto (insegnante). Se gli studenti non sentono di fare progressi nel loro apprendimento, si allontaneranno. In generale, \u00e8 possibile strutturare le lezioni in modo tale che gli studenti avvertano un progresso nell'aumento delle costruzioni familiari. Pertanto, iniziamo studiando in dettaglio i cicli while, poi quelli for, poi do while, e cos\u00ec abbiamo un corso che dura mille e una notte, in cui i cicli vengono studiati per due mesi, e alla fine c'\u00e8 uno studente che ha scritto la libreria standard su dettatura. Tuttavia, per risolvere compiti pratici, non basta conoscere il materiale, ma occorre anche autonomia nel suo utilizzo e nella ricerca di nuove informazioni. Pertanto, per i corsi in presenza, considero giusto il principio di insegnare le basi e incentivare lo studio autonomo di dettagli e argomenti correlati. Riguardo ai cicli, considero la costruzione while come il minimo essenziale. Da essa \u00e8 possibile comprendere il principio. Conoscendo il principio, \u00e8 possibile padroneggiare autonomamente anche for e do-while.<\/p>\n

Per favorire l'apprendimento del materiale da parte degli studenti pi\u00f9 deboli, non basta descrivere la sintassi. \u00c8 necessario fornire pi\u00f9 esercizi semplici ma variati e spiegare in dettaglio gli esempi. Alla fine, la velocit\u00e0 di apprendimento \u00e8 limitata dalla capacit\u00e0 dello studente di trasformare le espressioni e di cercare schemi. Per gli studenti intelligenti, la maggior parte degli esercizi risulter\u00e0 noiosa. Quando si lavora con loro, non \u00e8 necessario insistere sulla risoluzione del 100% dei problemi. Puoi vedere il mio materiale su il mio GitHub<\/a><\/noindex>. Tuttavia, il repository assomiglia pi\u00f9 a un grimorio da stregone: nessuno, tranne me, capir\u00e0 dove si trova cosa e se si falla un controllo, si potrebbe impazzire.<\/p>\n

Il metodo \u00e8 orientato alla pratica<\/h4>\n

\nLa teoria viene spiegata attraverso l'esempio di una soluzione. Durante le lezioni di programmazione di base, dove si studiano le diramazioni e i cicli, non \u00e8 possibile tenere una lezione utile su un solo argomento per un'ora intera. 15-20 minuti sono sufficienti per spiegare un concetto. Le principali difficolt\u00e0 sorgono durante l'esecuzione di compiti pratici.
\nI docenti principianti possono elencare operatori, diramazioni, cicli e array in un'unica lezione. Tuttavia, gli studenti si troveranno di fronte a un problema nell'assimilare queste informazioni.
\nNon \u00e8 sufficiente raccontare il materiale, bisogna anche assicurarsi che gli ascoltatori lo abbiano compreso.<\/p>\n

Il fatto che un argomento sia stato assimilato \u00e8 determinato da come lo studente gestisce il lavoro autonomo.
\nSe lo studente riesce a risolvere un problema sull'argomento senza l'aiuto dell'insegnante, significa che l'argomento \u00e8 stato assimilato. Per garantire un controllo autonomo, per ogni compito viene descritta una tabella con scenari di test. Gli esercizi seguono un ordine ben definito. \u00c8 sconsigliato saltare i compiti. Se un compito attuale \u00e8 troppo difficile, \u00e8 inutile passare al successivo, che sar\u00e0 ancora pi\u00f9 complesso. Per aiutare lo studente a superare un compito difficile, vengono spiegati alcuni approcci utilizzando l'esempio del primo compito. In sostanza, tutto il contenuto dell'argomento \u00e8 incentrato su strategie per superare le difficolt\u00e0. I cicli sono, piuttosto, un effetto collaterale.<\/p>\n

Il primo compito \u00e8 sempre un esempio. Il secondo differisce leggermente e viene eseguito \"autonomamente\" subito dopo il primo sotto la supervisione dell'insegnante. Tutti i successivi esercizi sono progettati per richiamare l'attenzione su piccoli dettagli che possono causare malintesi.<\/p>\n

La spiegazione di un esempio consiste in un dialogo in cui lo studente deve attivare il back propagation e la cross-validation per assicurarsi di aver assimilato il materiale.<\/p>\n

Sar\u00e0 banale, ma affermer\u00f2 che il primo esempio sull'argomento \u00e8 molto importante. Quando ci sono materiali per un ampio lavoro autonomo, le mancanze del primo esempio possono essere corrette. Se non c'\u00e8 nient'altro oltre all'esempio, \u00e8 probabile che lo studente non riesca ad assimilare l'argomento.<\/p>\n

While o for?<\/h4>\n

\nUno dei dibattiti \u00e8 la scelta della struttura per l'esempio: while o for. Un giorno, un mio amico sviluppatore professionista senza esperienza di insegnamento mi ha convinto per un'ora che il ciclo for \u00e8 il pi\u00f9 semplice da comprendere. Gli argomenti si riducevano al fatto che \"\u00e8 tutto chiaro e ben organizzato\". Tuttavia, la vera causa delle difficolt\u00e0 dei principianti risiede nell'idea stessa di ciclo, e non nella sua scrittura. Se una persona non comprende questa idea, avr\u00e0 difficolt\u00e0 con la sintassi. Non appena l'idea \u00e8 compresa, i problemi di codifica svaniscono da soli.<\/p>\n

Nei miei materiali, l'argomento dei cicli segue quello delle diramazioni. La somiglianza esterna tra if e while consente di tracciare un'analogia diretta: \"quando la condizione nell'intestazione \u00e8 vera, viene eseguito il corpo\". L'unica particolarit\u00e0 del ciclo \u00e8 che il corpo viene eseguito molte volte.<\/p>\n

Il secondo argomento a mio favore \u00e8 che while richiede meno processamento rispetto a for. Meno processamento significa meno errori stupidi con virgole e parentesi dimenticate. I principianti non hanno ancora sviluppato una sufficiente attenzione e meticolosit\u00e0 per evitare automaticamente gli errori di sintassi.
\nIl terzo argomento \u00e8 che in molti buoni libri while viene spiegato per primo.<\/p>\n

Se lo studente riesce a trasformare facilmente le espressioni, allora posso parlare di for passandoci sopra. Lo studente poi sceglier\u00e0 da solo cosa preferisce. Se invece le trasformazioni creano difficolt\u00e0, \u00e8 meglio non disperdere l'attenzione. Lascia che prima lo studente risolva tutto utilizzando while. Una volta che l'argomento dei cicli \u00e8 stato assimilato, si possono riscrivere le soluzioni per esercitarsi nella trasformazione da while a for.
\nI cicli con post-condizione sono piuttosto rari. Non ci perdo tempo affatto. Se lo studente ha compreso le idee di identificazione degli schemi e trasformazione delle espressioni, sar\u00e0 in grado di affrontarli senza il mio aiuto.<\/p>\n

Nella dimostrazione del primo esempio agli studenti avanzati, sottolineo che in questo caso \u00e8 fondamentale registrare non solo la soluzione, ma anche tutta la sequenza di azioni che hanno portato al risultato. Gli studenti superficiali possono trascurare la scrittura e limitarsi a riportare solo l'algoritmo finale. Devono essere convinti che prima o poi si troveranno di fronte a un compito complesso. Per risolverlo, sar\u00e0 necessario seguire i passaggi come in questo esempio. Per questo motivo \u00e8 importante registrare tutte le fasi. Nelle prossime attivit\u00e0, si potr\u00e0 presentare solo la versione finale della soluzione.<\/p>\n

L'idea principale dell'automazione \u00e8 che affidiamo al computer il compito di eseguire il lavoro di routine per l'uomo. Una delle tecniche fondamentali \u00e8 la scrittura di cicli. Viene utilizzata quando il programma esegue consecutivamente diverse azioni identiche e ripetitive.<\/p>\n

Il chiaro \u00e8 meglio dell'oscuro<\/h4>\n

\nPotrebbe sembrare una buona idea, nel primo esercizio sui cicli, stampare a schermo una frase identica pi\u00f9 volte. Ad esempio:<\/p>\n

Evviva, funziona!
\nEvviva, funziona!
\nEvviva, funziona!
\nEvviva, funziona!
\nEvviva, funziona!
\nEvviva, funziona!
\nEvviva, funziona!
\nEvviva, funziona!\n<\/p><\/blockquote>\n

\nQuesta soluzione \u00e8 scadente poich\u00e9 nell'output non si vede il valore del contatore. Questo rappresenta un problema per i principianti. Non bisogna sottovalutare questa difficolt\u00e0. Inizialmente, questo compito era il primo, mentre l'esercizio di stampa di una sequenza di numeri in ordine crescente era il secondo. Era necessario introdurre termini aggiuntivi come \"ciclo N volte\" e \"ciclo da A a B\", che in sostanza sono la stessa cosa. Per evitare di creare entit\u00e0 superflue, ho deciso di mostrare solo l'esempio della stampa di una sequenza di numeri. Pochi riescono, senza preparazione, a mantenere in mente il contatore e a modellare il comportamento del programma nella loro mente. Alcuni studenti si trovano per la prima volta a dover modellare \"in mente\" proprio con il tema dei cicli.
\nDopo un po' di pratica, la richiesta di ripetere lo stesso testo la assegno come esercizio autonomo. Se inizialmente mostriamo un contatore visibile e poi invisibile, gli studenti hanno meno difficolt\u00e0. A volte basta un suggerimento come \"non stampare il contatore a schermo\".<\/p>\n

Come viene spiegato altrove?<\/h4>\n

\nNella maggior parte dei materiali didattici online, la sintassi del ciclo \u00e8 presentata all'interno di una \"lezione\". Ad esempio, su developer.mozilla.org (attualmente) insieme al ciclo while vengono descritti anche altre costrutti. Vengono presentati esclusivamente i costrutti stessi come modelli. I risultati della loro esecuzione sono descritti a parole e manca l'illustrazione. A mio avviso, un approccio del genere riduce a zero l'utilit\u00e0 di tali materiali. Lo studente pu\u00f2 riscrivere il codice e farlo funzionare da solo, ma ha comunque bisogno di un modello di riferimento. Come si fa a sapere se l'esempio \u00e8 stato trascritto correttamente, se non c'\u00e8 nulla con cui confrontare il risultato?
\nQuando viene fornito solo un modello, senza esempio, lo studente trova ancora pi\u00f9 difficile capire. Come pu\u00f2 sapere se i frammenti di codice sono stati posizionati correttamente nel modello? Pu\u00f2 provare a scrivere in qualche modo<\/i>, e poi farlo eseguire. Ma se non c'\u00e8 un modello di riferimento per il risultato, l'esecuzione non aiuter\u00e0.<\/p>\n

Nel corso di C++, la sintassi del ciclo \u00e8 sepolta nella terza pagina della lezione 4 sul tema \"operatori\". Quando si spiega la sintassi dei cicli, si pone particolare enfasi sul termine \"operatore\". Questo termine \u00e8 presentato come un insieme di fatti, come \"simbolo; \u00e8 un operatore\", \"{} \u00e8 un operatore composto\", \"il corpo del ciclo deve essere un operatore\". Non mi piace questo approccio perch\u00e9 nasconde importanti correlazioni dietro a un singolo termine. L'analisi del codice sorgente del programma a questo livello \u00e8 necessaria per i programmatori di compilatori per implementare la specifica del linguaggio, ma non per gli studenti in una prima fase. I principianti nella programmazione raramente hanno la meticolosit\u00e0 necessaria per prestare tanta attenzione ai termini. \u00c8 raro che qualcuno riesca a memorizzare e a comprendere nuove parole la prima volta. Praticamente nessuno riesce a utilizzare correttamente un termine appena appreso. Di conseguenza, gli studenti commettono molti errori come \"ho scritto while(a<7);{, ma il programma non funziona".
\nA mio parere, all'inizio \u00e8 meglio fornire la sintassi della costruzione direttamente con le parentesi. La variante senza parentesi va spiegata solo se lo studente pone una domanda specifica \"perch\u00e9 qui senza parentesi e funziona\".<\/p>\n

Nel libro di Okulov \"Fondamenti della programmazione\" del 2012, l'incontro con i cicli inizia con il modello for, poi si forniscono raccomandazioni sul suo utilizzo e subito dopo c'\u00e8 una sezione di esperimenti. Ho l'impressione che il libro sia stato scritto per quella ristretta minoranza di studenti molto capaci, che raramente partecipano alle mie lezioni.<\/p>\n

Nei libri popolari viene sempre scritto il risultato dei frammenti di codice. Ad esempio, nel libro di Schildt \"Java 8. Guida completa\" del 2015. Prima viene fornito un modello, poi un esempio di programma e subito dopo il risultato dell'esecuzione.<\/p>\n

Prendiamo come esempio un ciclo while in cui viene eseguito un conteggio alla rovescia, partendo da 10, e vengono stampate esattamente 10 righe di \"battiti\":
\nDopo l'avvio, questo programma stampa dieci \"battiti\" nel modo seguente: <\/p>\n

\/\/\u041f\u0440\u043e\u0434\u0435\u043c\u043e\u043d\u0441\u0442\u0440\u0438\u0440\u043e\u0432\u0430\u0442\u044c \u043f\u0440\u0438\u043c\u0435\u043d\u0435\u043d\u0438\u0435 \u043e\u043f\u0435\u0440\u0430\u0442\u043e\u0440\u0430 \u0446\u0438\u043a\u043b\u0430 while\nclass While {\n    public static void main(String args []) {\n        int n = 10;\n        while (n > 0) {\n            System.out.println("\u0442\u0430\u043a\u0442 " + n);\n            n--;\n        }\n    }\n}<\/code><\/pre>\n
\nL'approccio con la descrizione del modello, il programma di esempio e il risultato di questo programma \u00e8 utilizzato anche nel libro \"Javascript for Kids\" e nel corso js su w3schools.com. Il formato della pagina web consente persino di rendere questo esempio interattivo.
\npasso 10
\npasso 9
\npasso 8
\npasso 7
\npasso 6
\npasso 5
\npasso 4
\npasso 3
\npasso 2
\npasso 1<\/code><\/p><\/blockquote>\n
\nNel libro di Stroustrup \"Principles and Practice Using C++\" del 2016, l'autore va ancora oltre. Inizia spiegando quale risultato si dovrebbe ottenere e solo dopo mostra il testo del programma. Inoltre, il programma non \u00e8 una semplice casualit\u00e0, ma fa un excursus nella storia. Questo aiuta a attirare l'attenzione su di esso: \"Guarda, questo non \u00e8 solo un testo inutile. Vedi qualcosa di significativo\".<\/p>\n
Come esempio di iterazione, consideriamo il primo programma eseguito su una macchina con programma memorizzato (EDSAC). \u00c8 stato scritto da David Wheeler nel laboratorio di informatica dell'Universit\u00e0 di Cambridge (Inghilterra) il 6 maggio 1949. Questo programma calcola e stampa un semplice elenco di quadrati.<\/p>\n
Qui, in ogni riga c'\u00e8 un numero seguito da un carattere di tabulazione ('t') e dal quadrato di quel numero. La versione di questo programma in C++ appare cos\u00ec:
\n0 0
\n1 1
\n2 4
\n3 9
\n4 16
\n...
\n98 9604
\n99 9801<\/code>
\nQui ogni riga contiene un numero seguito da un carattere di tabulazione ('t') e dal quadrato di quel numero. La versione di questo programma in C++ appare cos\u00ec:<\/p>\n
\/\/\u0412\u044b\u0447\u0438\u0441\u043b\u044f\u0435\u043c \u0438 \u0440\u0430\u0441\u043f\u0435\u0447\u0430\u0442\u044b\u0432\u0430\u0435\u043c \u0442\u0430\u0431\u043b\u0438\u0446\u0443 \u043a\u0432\u0430\u0434\u0440\u0430\u0442\u043e\u0432 \u0447\u0438\u0441\u0435\u043b 0-99\nint main()\n{\n    int i = 0; \/\/ \u041d\u0430\u0447\u0438\u043d\u0430\u0435\u043c \u0441 \u043d\u0443\u043b\u044f\n    while(i < 100){\n        cout << i << 't' << square(i) << 'n';\n        ++i;\n    }\n}<\/code><\/pre>\n<\/blockquote>\n
\nCome spiego io stessotraduzione<\/a><\/noindex>L'approccio di Stroustrup: descrivere il risultato, poi risolvere il problema e infine far analizzare autonomamente lo studente \u2014 appare il pi\u00f9 ragionato. Quindi ho deciso di adottare proprio il suo approccio, ma di parlare di un esempio meno storico: l'attivit\u00e0 di stampa di un \"indice\". Essa forma un'ancora riconoscibile, in modo tale da dire poi \"ricorda il problema dell'indice\" e affinch\u00e9 gli studenti lo ricordino esattamente. Nel mio esempio, ho cercato di prevenire anche due dei fraintendimenti pi\u00f9 comuni. Successivamente ne parler\u00f2 in modo pi\u00f9 dettagliato.<\/p>\n
In questo esercizio ci familiarizziamo con le tecniche di risoluzione di problemi complessi. La soluzione iniziale deve essere primitiva e semplice. Poi si pu\u00f2 pensare a come migliorare questa soluzione.<\/h4>\n
\nDalla mia osservazione, l'approccio \"modello-esempio-risultato\" in diverse combinazioni porta comunque al fatto che gli studenti percepiscono il ciclo come un geroglifico. Questo si manifestava nel fatto che non capivano perch\u00e9 fosse necessario scrivere una condizione, come scegliere tra i++ e i-- e altre cose apparentemente ovvie. Per evitare questi fraintendimenti, l'approccio alla spiegazione dei cicli deve sottolineare il significato della ripetizione di azioni identiche e solo dopo \u2014 la loro formalizzazione attraverso la costruzione. Pertanto, prima di fornire la sintassi del ciclo, \u00e8 necessario risolvere il problema \"in modo diretto\". La soluzione primitiva del problema dell'indice appare cos\u00ec:<\/p>\n
Console.WriteLine(\"Introduzione\");\nConsole.WriteLine(\"Capitolo 1\");\nConsole.WriteLine(\"Capitolo 2\");\nConsole.WriteLine(\"Capitolo 3\");\nConsole.WriteLine(\"Capitolo 4\");\nConsole.WriteLine(\"Capitolo 5\");\nConsole.WriteLine(\"Capitolo 6\");\nConsole.WriteLine(\"Capitolo 7\");\nConsole.WriteLine(\"Conclusione\");
\nIntroduzione
\nCapitolo 1
\nCapitolo 2
\nCapitolo 3
\nCapitolo 4
\nCapitolo 5
\nCapitolo 6
\nCapitolo 7
\nConclusione<\/code><\/p><\/blockquote>\n
\nDalla mia esperienza, l'approccio \"modello-esempio-risultato\" in diverse combinazioni porta comunque a far percepire agli studenti il ciclo come un geroglifico. Questo si manifestava nel fatto che non capivano perch\u00e9 fosse necessario scrivere una condizione, come scegliere tra i++ e i-- e altre cose apparentemente ovvie. Per evitare questi fraintendimenti, l'approccio alla spiegazione dei cicli dovrebbe sottolineare il significato della ripetizione di azioni identiche e solo dopo \u2013 la loro formalizzazione tramite la struttura. Pertanto, prima di fornire la sintassi del ciclo, \u00e8 necessario affrontare il problema \"alla radice\". Una soluzione primitiva al problema del sommario appare cos\u00ec:<\/p>\n
Console.WriteLine(\"Introduzione\");\nConsole.WriteLine(\"Capitolo 1\");\nConsole.WriteLine(\"Capitolo 2\");\nConsole.WriteLine(\"Capitolo 3\");\nConsole.WriteLine(\"Capitolo 4\");\nConsole.WriteLine(\"Capitolo 5\");\nConsole.WriteLine(\"Capitolo 6\");\nConsole.WriteLine(\"Capitolo 7\");\nConsole.WriteLine(\"Conclusione\");\n<\/code><\/pre>\n
\nQuali azioni qui si ripetono consecutivamente senza modifiche?
\nIn questo frammento non ce ne sono. In effetti, i comandi per stampare la parola \"Capitolo\" con il numero sono molto simili tra loro.
\nQuindi la fase successiva \u00e8 cercare le differenze tra i frammenti. Solo in questo problema tutto \u00e8 ovvio, in seguito si ripeteranno non singoli comandi, ma blocchi di codice di 5 righe o pi\u00f9. Sar\u00e0 necessario cercare non solo nella lista dei comandi, ma nelle strutture di ramificazione o ciclo.
\nNel esempio la differenza tra i comandi \u00e8 nel numero dopo la parola \"Capitolo\".
\nAppena trovata la differenza, \u00e8 necessario capire la regolarit\u00e0 della modifica. Il frammento differente \u00e8 un numero? Aumenta costantemente o diminuisce? Come cambia il valore del numero tra due comandi vicini?
\nNel esempio, il numero dopo la parola \"Capitolo\" aumenta di passi di 1. La differenza \u00e8 stata trovata, la regolarit\u00e0 \u00e8 stata rilevata. Ora si pu\u00f2 sostituire il frammento differente con una variabile.
\nDovremmo dichiarare questa variabile prima del primo dei frammenti ripetuti. Questa variabile viene solitamente chiamata i o j o in modo pi\u00f9 esplicito. Il suo valore iniziale dovrebbe essere uguale al primo valore che verr\u00e0 visualizzato sullo schermo. In questo esempio, il primo valore \u00e8 1.
\nQuale valore iniziale dobbiamo prendere per stampare la serie di numeri \"100, 101, 102, 103, 104, 105\"?
\nIn questa serie, il primo numero \u00e8 100. 
\nDopo ogni comando di stampa, \u00e8 necessario incrementare il valore di questa variabile di 1. Questa unit\u00e0 rappresenta il passo di cambiamento.
\nIn this row, the first number is 100.
\nAfter each output command, you need to increase the value of this variable by 1. This unit is the step change.
\nQual \u00e8 il passo nella sequenza di numeri \u00ab100, 102, 104, 106\u00bb?
\nIn questa sequenza il passo \u00e8 2.
\nDopo aver sostituito il frammento variabile, il codice apparir\u00e0 cos\u00ec:<\/p>\n
Console.WriteLine(\"Introduzione\");\nint i;\ni = 0;\nConsole.WriteLine(\"Capitolo \" + i);\ni = i + 1;\nConsole.WriteLine(\"Capitolo \" + i);\ni = i + 1;\nConsole.WriteLine(\"Capitolo \" + i);\ni = i + 1;\nConsole.WriteLine(\"Capitolo \" + i);\ni = i + 1;\nConsole.WriteLine(\"Capitolo \" + i);\ni = i + 1;\nConsole.WriteLine(\"Capitolo \" + i);\ni = i + 1;\nConsole.WriteLine(\"Capitolo \" + i);\ni = i + 1;\nConsole.WriteLine(\"Conclusione\");\n<\/code><\/pre>\n
\nDopo aver applicato il metodo \"esprimere la regolarit\u00e0 come variabile\", il codice risulta in pi\u00f9 gruppi di azioni identiche che si susseguono. Ora le azioni ripetitive possono essere sostituite con un ciclo.<\/p>\n
La sequenza per risolvere il problema, dove \u00e8 necessario usare i cicli, consiste nei seguenti passaggi:<\/p>\n
    \n
  1. Risolvere \"a brutto\" con una serie di comandi separati<\/li>\n
  2. Trovare la regolarit\u00e0<\/li>\n
  3. Esprimere la regolarit\u00e0 come variabile<\/li>\n
  4. Formulare come ciclo<\/li>\n<\/ol>\n
    In seguito vengono introdotti nuovi termini, affinch\u00e9 lo studente non si trovi nella situazione \"capisco tutto, ma non riesco a dire\":
    \n \u2014 contatore \u2014 \u00e8 sempre una variabile necessaria per tenere traccia del numero di iterazioni del ciclo. Di solito \u00e8 un numero intero, confrontato con un limite.
    \n \u2014 passo del contatore \u2014 descrizione della regolarit\u00e0 della modifica del contatore.
    \n \u2014 limite \u2014 numero o variabile confrontati con il contatore, affinch\u00e9 l'algoritmo sia finito. Il valore del contatore viene modificato per avvicinarsi al limite.
    \n \u2014 corpo del ciclo \u2014 insieme di comandi che verranno ripetuti. Quando si dice \"il comando \u00e8 scritto all'interno del ciclo\", si riferisce specificamente al corpo.
    \n \u2014 iterazione del ciclo \u2014 esecuzione singola del corpo del ciclo.
    \n \u2014 condizione del ciclo \u2014 espressione logica dalla quale dipende se verr\u00e0 eseguita un'altra iterazione. (Qui potrebbe esserci confusione con le strutture di ramificazione)
    \n\u00c8 necessario essere pronti al fatto che inizialmente gli studenti useranno i termini in modo errato. Questo vale sia per quelli forti che per quelli deboli. Stabilire un linguaggio comune \u00e8 un'arte. Ora scriver\u00f2 brevemente: bisogna porre l'obiettivo \"evidenzia il frammento di codice con \" e utilizzare correttamente questi termini nella conversazione.
    \nDopo la trasformazione usando il ciclo, il frammento risulta:<\/p>\n
    Console.WriteLine(\"Introduzione\");\nint i = 0;\nwhile (i < 7) {\n    Console.WriteLine("Capitolo " + i);\n    i = i + 1;\n}\nConsole.WriteLine("Conclusione");<\/code><\/pre>\n
    Falsa convinzione principale<\/h4>\n
    \nUna comune falsa convinzione tra gli studenti \u00e8 che mettano all'interno della struttura di ciclo azioni che devono essere eseguite solo una volta. Ad esempio, cos\u00ec:<\/p>\n
    ;\nint i = 0;\nwhile (i < 7) {\n    Console.WriteLine("Introduzione")\n    Console.WriteLine("Capitolo " + i);\n    i = i + 1;\n    Console.WriteLine("Conclusione");\n}\n<\/code><\/pre>\n
    \nGli studenti si scontrano costantemente con questo problema, sia all'inizio sia in compiti pi\u00f9 complessi.
    \nUn suggerimento chiave in questo caso:<\/p>\n
    Quante volte \u00e8 necessario ripetere la scrittura del comando: una volta o molte?\n<\/p><\/blockquote>\n
    \nI comandi per stampare \"Introduzione\" e \"Conclusione\", cos\u00ec come la dichiarazione e l'inizializzazione della variabile i, non assomigliano ad altre azioni ripetitive. Vengono eseguiti solo una volta, quindi devono essere scritti al di fuori del corpo del ciclo.<\/p>\n
    Nel codice devono rimanere tutte e tre le fasi della soluzione, in modo da poterle richiamare in caso di difficolt\u00e0. I primi due modi \u00e8 sufficiente comentarli affinch\u00e9 non infastidiscano.
    \nL'attenzione dello studente deve essere rivolta ai seguenti fatti:
    \n \u2014 Nella condizione del ciclo di solito si confrontano contatore e limite. Il contatore pu\u00f2 cambiare all'interno del ciclo, mentre il limite non pu\u00f2. Per violare questa regola, ci devono essere motivi validi.
    \n \u2014 I comandi per stampare le parole 'Introduzione' e 'Conclusione' si trovano al di fuori del corpo del ciclo. Devono essere eseguiti 1 volta. 'Introduzione' \u2014 prima delle azioni ripetute, 'Conclusione' \u2014 dopo.
    \nDurante il consolidamento di questo argomento, l'apprendimento dei successivi e la risoluzione di difficolt\u00e0, \u00e8 utile anche per gli studenti forti porre la domanda: \"Questa azione quante volte deve essere eseguita? Una o molte?\".<\/p>\n
    Sviluppo di abilit\u00e0 aggiuntive<\/h4>\n
    \nDurante lo studio dei cicli, gli studenti affinano anche l'abilit\u00e0 di diagnosi e risoluzione dei problemi. Per condurre una diagnosi, lo studente deve rappresentare il risultato desiderato e confrontarlo con il risultato effettivo. La differenza tra di loro determina le azioni correttive.
    \nPoich\u00e9 gli studenti in questa fase hanno ancora una scarsa idea del \"desiderato\" risultato, possono orientarsi sui dati di test. Di solito in questa fase nessuno capisce ancora cosa potrebbe andare storto e come affrontarlo. Pertanto, fornisco per la scrittura nel quaderno una descrizione di problemi tipici e alcuni modi per risolverli. Scegliere il pi\u00f9 adeguato \u00e8 compito dello stesso studente.
    \n\u00c8 necessario chiedere \"\u00e8 andato come previsto?\", \"Quale di queste situazioni si \u00e8 verificata ora?\", \"La soluzione applicata ha aiutato?\".<\/p>\n
      \n
    1. Il numero di azioni \u00e8 uno in meno o uno in pi\u00f9 di quanto previsto. Modi per risolvere:
      \n \u2014 aumentare il valore iniziale del contatore di 1.
      \n \u2014 sostituire l'operatore di confronto rigoroso (< o >) con un confronto non rigoroso (<= o >=).
      \n \u2014 modificare il valore del limite di 1.<\/li>\n
    2. Le azioni nel ciclo vengono eseguite senza fermarsi, all'infinito. Modi per risolvere:
      \n \u2014 aggiungere un comando per modificare il contatore, se manca.
      \n \u2014 correggere il comando di modifica del contatore in modo che il suo valore si avvicini al limite.
      \n \u2014 rimuovere il comando di modifica del limite, se si trova nel corpo del ciclo.<\/li>\n
    3. Il numero di azioni nel ciclo \u00e8 pi\u00f9 di 1 in meno o in pi\u00f9 di quanto previsto. L'azione nel ciclo non \u00e8 stata eseguita nemmeno una volta. Prima \u00e8 necessario determinare i valori effettivi delle variabili immediatamente prima dell'inizio del ciclo. Modi per risolvere:
      \n \u2014 modificare il valore iniziale del limite
      \n \u2014 modificare il valore iniziale del contatore<\/li>\n<\/ol>\n
      \nDi solito, il problema 3 \u00e8 legato all'uso della variabile sbagliata o al non azzeramento del contatore.<\/p>\n
      Dopo questa spiegazione, lo studente potrebbe avere ancora varie errate convinzioni riguardo al funzionamento dei cicli.
      \nPer chiarire le pi\u00f9 comuni, propongo esercizi:<\/p>\n
        \n
      1. In cui il limite, il valore iniziale del contatore o il passo del contatore vengono inseriti dall'utente.<\/li>\n
      2. In cui il valore del contatore deve essere utilizzato in qualche espressione aritmetica. Preferibilmente con il contatore in un'espressione radice o nel denominatore, in modo che la differenza sia non lineare.<\/li>\n
      3. In cui il valore del contatore non viene mostrato sullo schermo durante l'esecuzione del ciclo. Ad esempio, per stampare un numero specifico di frammenti di testo identici o disegnare una figura con grafica turtle.<\/li>\n
      4. In cui devono essere eseguite prima alcune azioni ripetitive, e poi altre.<\/li>\n
      5. In cui devono essere eseguite altre azioni prima e dopo quelle ripetitive.<\/li>\n<\/ol>\n
        \nPer ogni esercizio devono essere forniti dati di prova e risultati attesi.<\/p>\n
        Per capire quanto velocemente si pu\u00f2 procedere, \u00e8 necessario dare tempo per leggere le condizioni di questi esercizi e chiedere: \"in cosa differiscono dall'esempio?\", \"Cosa bisogna cambiare nell'esempio per risolverli?\". Se lo studente risponde in modo consapevole, allora pu\u00f2 risolverne almeno uno in classe, mentre gli altri a casa autonomamente. Se la soluzione ha successo, allora si pu\u00f2 iniziare la spiegazione sulle condizioni all'interno dei cicli.
        \nSe ci sono difficolt\u00e0 con la soluzione autonoma, \u00e8 necessario lavorare su tutto in classe. Per evitare che la soluzione del problema somigli a un disegno di un gufo, consiglio di risolvere inizialmente il problema in modo non universale. Cio\u00e8, in modo che la soluzione superi il primo test e non utilizzi la struttura del ciclo. Poi, si possono applicare trasformazioni per ottenere la universalit\u00e0 della soluzione.<\/p>\n
        Cicli e ramificazioni<\/h4>\n
        \nA mio avviso, \u00e8 utile trattare il tema \"cicli all'interno delle ramificazioni\" separatamente. Cos\u00ec, poi sar\u00e0 evidente la differenza tra il controllo multiplo di una condizione e quello singolo.
        \nGli esercizi di consolidamento riguarderanno la visualizzazione dei numeri da A a B, che vengono inseriti dall'utente:
        \n \u2014 sempre in ordine crescente.
        \n \u2014 in ordine crescente o decrescente a seconda dei valori di A e B.<\/p>\n
        Per il tema \"diramazione all'interno dei cicli\", bisogna passare solo dopo che lo studente ha acquisito le competenze: \"sostituzione di una regolarit\u00e0 con una variabile\" e \"sostituzione di azioni ripetute con un ciclo\".
        \nLa principale ragione per applicare ramificazioni all'interno dei cicli sono le anomalie nella regolarit\u00e0. In mezzo, essa viene interrotta a seconda dei dati di partenza.
        \nAgli studenti capaci di cercare soluzioni mediante la combinazione di semplici tecniche, basta dire: \"le ramificazioni possono essere scritte all'interno dei cicli\" e dare un esercizio \"per esempio\" completamente da risolvere autonomamente.
        \nEsercizio per esempio:<\/p>\n
        L'utente inserisce il numero X. Visualizzare in colonna i numeri da 0 a 9 e mettere il segno '+' accanto al numero che \u00e8 uguale a X.<\/p><\/blockquote>\n
        \nSe \u00e8 stato inserito 0<\/b>0+
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9<\/p>\n
        Se \u00e8 stato inserito 6<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6+
        \n7
        \n8
        \n9<\/p>\n
        Se \u00e8 stato inserito 9<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9+<\/p>\n
        Se \u00e8 stato inserito 777<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9<\/p>\n
        Se la breve spiegazione non \u00e8 sufficiente per scrivere con il ciclo, allora \u00e8 necessario ottenere una soluzione universale dello stesso problema senza ciclo.
        \nOtterrai una delle due opzioni:
        \nDesiderato<\/b><\/p>\n
        string temp;\ntemp = Console.ReadLine();\nint x;\nx = int.Parse(temp);\nif (x==0) {\n    Console.WriteLine(0 + \"+\");\n} else {\n    Console.WriteLine(0);\n}\nif (x==1) {\n    Console.WriteLine(1 + \"+\");\n} else {\n    Console.WriteLine(1);\n}\nif (x==2) {\n    Console.WriteLine(2 + \"+\");\n} else {\n    Console.WriteLine(2);\n}\nif (x==3) {\n    Console.WriteLine(3 + \"+\");\n} else {\n    Console.WriteLine(3);\n}\nif (x==4) {\n    Console.WriteLine(4 + \"+\");\n} else {\n    Console.WriteLine(4);\n}\nif (x==5) {\n    Console.WriteLine(5 + \"+\");\n} else {\n    Console.WriteLine(5);\n}\nif (x==6) {\n    Console.WriteLine(6 + \"+\");\n} else {\n    Console.WriteLine(6);\n}\nif (x==7) {\n    Console.WriteLine(7 + \"+\");\n} else {\n    Console.WriteLine(7);\n}\nif (x==8) {\n    Console.WriteLine(8 + \"+\");\n} else {\n    Console.WriteLine(8);\n}\nif (x==9) {\n    Console.WriteLine(9 + \"+\");\n} else {\n    Console.WriteLine(9);\n}\n<\/code><\/pre>\n
        Possibile<\/b><\/p>\n
        string temp;\ntemp = Console.ReadLine();\nint x;\nx = int.Parse(temp);\nif (x==0) {\n    Console.WriteLine(\"0n1n2n3n4n5n6n7n8n9\");\n}\nif (x==1) {\n    Console.WriteLine(\"0n1+n2n3n4n5n6n7n8n9\");\n}\nif (x==2) {\n    Console.WriteLine(\"0n1n2+n3n4n5n6n7n8n9\");\n}\nif (x==3) {\n    Console.WriteLine(\"0n1n2n3+n4n5n6n7n8n9\");\n}\nif (x==4) {\n    Console.WriteLine(\"0n1n2n3n4+n5n6n7n8n9\");\n}\nif (x==5) {\n    Console.WriteLine(\"0n1n2n3n4n5+n6n7n8n9\");\n}\nif (x==6) {\n    Console.WriteLine(\"0n1n2n3n4n5n6+n7n8n9\");\n}\nif (x==7) {\n    Console.WriteLine(\"0n1n2n3n4n5n6n7+n8n9\");\n}\nif (x==8) {\n    Console.WriteLine(\"0n1n2n3n4n5n6n7n8+n9\");\n}\nif (x==9) {\n    Console.WriteLine(\"0n1n2n3n4n5n6n7n8n9+\");\n}\n<\/code><\/pre>\n
        Do solito fornisco un compito simile in anticipo, durante lo studio del tema sui ramificazioni.
        \nSe lo studente ha ottenuto una variante \u00abpossibile\u00bb, \u00e8 importante spiegare che per uno stesso problema possono esserci molte soluzioni. Tuttavia, queste differiscono per la loro robustezza ai cambiamenti dei requisiti. Fai la domanda: \u00abQuanti punti nel codice dovranno essere modificati se sar\u00e0 necessario aggiungere un altro numero?\u00bb Nella variante \u00abpossibile\u00bb dovr\u00e0 essere aggiunta un'altra ramificazione e modificato in dieci altri luoghi il nuovo numero. In quella \u00abdesiderata\u00bb baster\u00e0 aggiungere solo una ramificazione.
        \nAssegna il compito di riprodurre la variante \u00abdesiderata\u00bb, quindi di identificare nel codice delle regole, eseguire la sostituzione della variabile e scrivere un ciclo.
        \nSe hai idee su come risolvere questo problema senza un ciclo in un altro modo, per favore scrivile nei commenti.<\/p>\n
        Cicli all'interno di cicli<\/h4>\n
        \nIn questo tema \u00e8 importante notare che:
        \n \u2014 i contatori per il ciclo interno ed esterno devono essere diverse variabili.
        \n \u2014 il contatore per il ciclo interno deve essere azzerato molte volte (cio\u00e8 nel corpo del ciclo esterno).
        \n \u2014 nei problemi di output di testo non si pu\u00f2 scrivere inizialmente una lettera su pi\u00f9 righe e poi la successiva. Prima bisogna stampare tutte le lettere della prima riga, poi tutte le lettere della seconda e cos\u00ec via.<\/p>\n
        \u00c8 meglio iniziare la spiegazione del tema sui cicli all'interno dei cicli spiegando l'importanza di azzerare il contatore.
        \nEsercizio per esempio:<\/p>\n
        L'utente inserisce due numeri: R e T. Stampare due righe di caratteri \"#\". Nella prima riga ci devono essere R caratteri. Nella seconda riga T caratteri. Se uno dei numeri \u00e8 negativo, visualizzare un messaggio di errore.<\/p><\/blockquote>\n
        \nR=5, T=11<\/b>#####
        \n###########<\/p>\n
        R=20, T=3<\/b>####################
        \n###<\/p>\n
        R=-1, T=6<\/b>Il valore di R deve essere non negativo<\/p>\n
        R=6, T=-2<\/b>Il valore di T deve essere non negativo<\/p>\n
        \u00c8 chiaro che anche questo problema ha almeno due possibili soluzioni.
        \nDesiderato<\/b><\/p>\n
        string temp;\nint R;\nint T;\ntemp = Console.ReadLine();\nR = int.Parse(temp);\ntemp = Console.ReadLine();\nT = int.Parse(temp);\nint i = 0;\nwhile (i < R)\n{\n    Console.Write("#");\n    i = i + 1;\n}\nConsole.WriteLine();\ni = 0;\nwhile (i < T)\n{\n    Console.Write("#");\n    i = i + 1;\n}\n<\/code><\/pre>\n
        Possibile n. 1<\/b><\/p>\n
        string temp;\nint R;\nint T;\ntemp = Console.ReadLine();\nR = int.Parse(temp);\ntemp = Console.ReadLine();\nT = int.Parse(temp);\nint i = 0;\nwhile (i < R)\n{\n    Console.Write("#");\n    i = i + 1;\n}\nConsole.WriteLine();\nint j = 0;\nj = 0;\nwhile (j < T)\n{\n    Console.Write("#");\n    j = j + 1;\n}\n<\/code><\/pre>\n
        La differenza \u00e8 che nella soluzione \u00abpossibile\u00bb per l'output della seconda riga \u00e8 stata utilizzata una seconda variabile. \u00c8 necessario insistere sull'uso della stessa variabile per entrambi i cicli. Si pu\u00f2 argomentare questa limitazione dicendo che una soluzione con un solo contatore per due cicli sar\u00e0 un'illustrazione del termine \u00abazzeramento del contatore\u00bb. Comprendere questo termine \u00e8 necessario per risolvere i prossimi problemi. Come compromesso, si possono mantenere entrambe le soluzioni del problema.<\/p>\n
        Un problema tipico con l'uso di una sola variabile contatore per due cicli si manifesta cos\u00ec:
        \nR=5, T=11<\/b>#####
        \n######<\/p>\n
        Il numero di simboli nella seconda riga non corrisponde al valore di T. Se hai bisogno di aiuto con questo problema, \u00e8 necessario \u00abpunzecchiare\u00bb nel riassunto sui problemi tipici con i cicli. Questo \u00e8 il sintomo n. 3. Si diagnostica se si aggiunge l'output del valore del contatore immediatamente prima del secondo ciclo. Si corregge azzerando. Ma \u00e8 meglio non dirlo subito. Lo studente dovrebbe cercare di formulare almeno un'ipotesi.<\/p>\n
        Ci sono sicuramente anche altre soluzioni. Ma non le ho mai viste tra gli studenti. Durante lo studio dei cicli, parlarne distrarrebbe l'attenzione. Si pu\u00f2 tornare su di esso pi\u00f9 tardi, studiando le funzioni legate alle stringhe.
        \nPossibile n. 2<\/b><\/p>\n
        string temp;\nint R;\nint T;\ntemp = Console.ReadLine();\nR = int.Parse(temp);\ntemp = Console.ReadLine();\nT = int.Parse(temp);\nConsole.WriteLine(new String('#', R));\nConsole.WriteLine(new String('#', T));\n<\/code><\/pre>\n
        \nIl prossimo compito obbligatorio:<\/p>\n
        Stampa sullo schermo i numeri da 0 a 9. Ogni numero deve essere su una propria riga. Il numero di cifre per riga (W) viene inserito dalla tastiera.<\/p><\/blockquote>\n
        \nW=1<\/b>0
        \n1
        \n2
        \n3
        \n4
        \n5
        \n6
        \n7
        \n8
        \n9<\/p>\n
        W=10<\/b>0000000000
        \n1111111111
        \n2222222222
        \n3333333333
        \n4444444444
        \n5555555555
        \n6666666666
        \n7777777777
        \n8888888888
        \n9999999999<\/code><\/p>\n
        Se uno studente ha appreso la tecnica per sostituire una variabile, dovrebbe riuscirci piuttosto rapidamente. Il problema potrebbe tornare a essere l'azzeramento della variabile. Se non riesce a effettuare la conversione, significa che hai fretta e che \u00e8 necessario risolvere problemi pi\u00f9 semplici.<\/p>\n
        Grazie per l'attenzione. Metti mi piace e iscriviti al canale.<\/p>\n
        P.S. Se hai trovato refusi o errori nel testo, ti prego di farmelo sapere. Puoi farlo evidenziando una parte del testo e premendo su Mac \u00ab\u2318 + Enter\u00bb, e sulle tastiere classiche \u00abCtrl \/ Enter\u00bb, oppure tramite messaggi privati. Se queste opzioni non sono disponibili, scrivi gli errori nei commenti. Grazie!<\/p>\n
        Solo gli utenti registrati possono partecipare al sondaggio. Accedi<\/a><\/noindex>, per favore.<\/p>\n
        Sondaggio per lettori senza karma<\/h2>\n