triennale-appunti-steffo/docs/route-AlgoritmiEStruttureDati.chunk.02d3a.esm.js

(window.webpackJsonp=window.webpackJsonp||[]).push([[3],{"ox/y":function(n,e,i){"use strict";function o(n,e){if(!n)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!e||"object"!=typeof e&&"function"!=typeof e?n:e}Object.defineProperty(e,"__esModule",{value:!0}),e.Link=e.Match=void 0;var a=Object.assign||function(n){for(var e=1;e<arguments.length;e++){var i=arguments[e];for(var o in i)Object.prototype.hasOwnProperty.call(i,o)&&(n[o]=i[o])}return n},r=i("hosL"),t=i("Y3FI"),l=e.Match=function(n){function e(){for(var e,i,a=arguments.length,r=Array(a),t=0;t<a;t++)r[t]=arguments[t];return e=i=o(this,n.call.apply(n,[this].concat(r))),i.update=function(n){i.nextUrl=n,i.setState({})},o(i,e)}return function(n,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function, not "+typeof e);n.prototype=Object.create(e&&e.prototype,{constructor:{value:n,enumerable:!1,writable:!0,configurable:!0}}),e&&(Object.setPrototypeOf?Object.setPrototypeOf(n,e):n.__proto__=e)}(e,n),e.prototype.componentDidMount=function(){t.subscribers.push(this.update)},e.prototype.componentWillUnmount=function(){t.subscribers.splice(t.subscribers.indexOf(this.update)>>>0,1)},e.prototype.render=function(n){var e=this.nextUrl||(0,t.getCurrentUrl)(),i=e.replace(/\?.+$/,"");return this.nextUrl=null,n.children({url:e,path:i,matches:!1!==(0,t.exec)(i,n.path,{})})},e}(r.Component),s=function(n){var e=n.activeClassName,i=n.path,o=function(n,e){var i={};for(var o in n)e.indexOf(o)>=0||Object.prototype.hasOwnProperty.call(n,o)&&(i[o]=n[o]);return i}(n,["activeClassName","path"]);return(0,r.h)(l,{path:i||o.href},(function(n){return(0,r.h)(t.Link,a({},o,{class:[o.class||o.className,n.matches&&e].filter(Boolean).join(" ")}))}))};e.Link=s,e.default=l,l.Link=s},w9qZ:function(n,e,i){"use strict";i.r(e),function(n){var o=i("sJH0"),a=i("imVn");i("ox/y");let r,t=n=>n;const l=String.raw;e.default=function(){return n("div",null,n(a.a,null,n(o.a,null,l(r||(r=t`
                    # Algoritmi e Strutture Dati

                    Docente: [**Manuela Montangero**](mailto:manuela.montangero@unimore.it)

                    Crediti: **9 CFU** (72 ore di lezione)

                    Orario di ricevimento: **Giovedì dalle 14:30 alle 16:30**
                    _Mandare una mail prima, altrimenti potrebbe andarsene_


                    #### Regole particolari per le email

                    - Oggetto "ASD"
                    - Mail **firmata** con **nome e cognome**
                    - Mail spedita dall'**account Unimore**

                    ### Materiale

                    Libri:
                    - **Introduzione agli Algoritmi e Strutture Dati** di _T.H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein_

                    **[Dolly (FIM)](https://dolly.fim.unimore.it/2018/course/view.php?id=26)**

                    ### Tutorato

                    Tutor: [**Gianluca d'Addese**](mailto:tutoratoalgoritmi@gmail.com)

                    Cosa: **Esercizi sugli argomenti visti a lezione** e **preparatori all'esame**

                    Quando: **Mercoledì dalle 09:00 alle 11:00**...?

                    ### Esame

                    Per iscriversi all'esame, bisogna aver passato:

                    - Analisi matematica (propedeutica)
                    - Programmazione I

                    Formato:

                    - Prima prova scritta
                    - Risolvere problemi con algoritmi proposti a lezione
                    - E' un test sulla preparazione
                    - Dura 1h30m
                    - Non si può usare nessun tipo di materiale
                    - Seconda prova scritta
                    - Proponi soluzioni per nuovi problemi non studiati a lezione
                    - Domande teoriche sugli argomenti studiati
                    - Dura 2h
                    - E' il giorno dopo la prima prova
                    - Si può utilizzare qualsiasi materiale, ma non deve permettere di comunicare
                    - Orale facoltativo
                    - Solo per chi supera entrambi gli scritti
                    - Domande su quello che abbiamo visto a lezione ("perchè gli algoritmi funzionano?")
                    - Informare via email entro 3 giorni dalla pubblicazione degli esiti della seconda prova
                    - L'orale potrebbe migliorare o peggiorare il voto (anche "molto")

                    **Attenzione:** Vengono verbalizzati anche i voti insufficienti; ricordarsi di rifiutarli!

                    Ci sono i seguenti appelli:

                    - 3 appelli tra Giugno e Luglio
                    - 1 appello a Settembre
                    - 2 appelli a Gennaio e Febbraio

                    Vale il salto di appello se:

                    - Uno studente regolarmente iscritto **non si presenta** all'appello e non ha avvisato via email almeno il giorno prima.
                    - Uno studente ha riportato una **grave insufficienza** in uno dei due scritti, e l'appello successivo è nella stessa sessione


                    ### Note

                    Il corso è ben collegato con quello di Programmazione 2.

                    Dormire non fa bene!
                `)))),n(a.a,null,n(o.a,null,"\n                    # Il nome del corso\n\n                    ## Cosa sono gli algoritmi?\n\n                    Gli algoritmi sono modi sistematici per risolvere problemi.\n\n                    Sono fondamentali per sviluppare software, in quanto i computer sono eccellenti esecutori di algoritmi.\n\n                    ## Come si sviluppa un algoritmo?\n\n                    Innanzitutto, bisogna conoscere gli _input_ e gli _output_ del problema, rispettivamente i dati di partenza e i dati di arrivo di esso; si ha quindi una fase di **ricerca**.\n\n                    Poi, si deve trovare un procedimento che ci faccia risolvere il nostro problema: è quello che faremo in questa materia!\n\n                    Infine, bisogna scrivere la soluzione in un modo che possa essere eseguita da un computer: questa è la **programmazione**.\n\n                    ## Che tipo di problemi possiamo risolvere?\n\n                    Un algoritmo risolve problemi di tipo generale, non ci interessa sapere _il risultato di 123+456_, ma vogliamo sapere _il risultato di x+y_, dove x e y sono due numeri naturali qualsiasi.\n\n                    Un problema può essere quindi considerato circa come una **funzione matematica**, che connette ogni input a un output corrispondente.\n\n                    ## Che caratteristiche ha un algoritmo?\n\n                    Per prima cosa, ripetendo l'algoritmo più volte con lo stesso ingresso deve dare sempre la stessa uscita come **risultato**, finendo in un **tempo finito**.\n\n                    Deve essere **ben ordinato**: cambiando l'ordine in cui vengono effettuate le operazioni, è probabile che anche il risultato cambi!\n\n                    Le sue istruzioni devono essere **non ambigue**, cioè che non possano essere interpretate in più modi, e **effettivamente realizzabili**, cioè realizzabili con l'esecutore che vogliamo usare per eseguire l'algoritmo.\n\n                    ## Esistono algoritmi equivalenti?\n\n                    **Sì!** Possono esserci due algoritmi che dati gli stessi input, hanno gli stessi output, e quindi risolvono lo stesso problema.\n\n                    In compenso, possono avere un numero di operazioni diverse, e quindi essere **uno più veloce** (da eseguire) dell'altro.\n\n                    ## Come si verifica la correttezza di un algoritmo?\n\n                    L'algoritmo deve essere **valido per tutti gli input**, anche se questi sono infiniti.\n\n                    Possiamo effettuare prove matematiche per verificarne la correttezza; il **principio di induzione** è dunque una dei teoremi fondamentali dell'algoritmica.\n\n                    Possiamo però verificare la _non correttezza_ di un algoritmo trovando un singolo controesempio.\n                ")),n(a.a,null,n(o.a,null,"\n                    # Efficienza degli algoritmi\n                    \n                    Un buon algoritmo deve essere **efficiente**, ovvero deve usare il minimo delle risorse necessarie, come _usare il minimo di tempo possibile_.\n                    \n                    ## Come misuriamo il tempo necessario?\n                    \n                    Cerchiamo di astrarre il tempo dal particolare esecutore, e andiamo a contare il numero di operazioni elementari richieste per eseguire il nostro algoritmo nel caso peggiore.\n                    \n                    Un algoritmo efficiente, infatti, all'aumentare dei dati in ingresso, diventerà sempre più veloce rispetto a uno non efficiente, anche su computer più lenti!\n                    \n                    > Il [Bubble Sort](https://en.wikipedia.org/wiki/Bubble_sort) è sempre più lento di un [Tree Sort](https://en.wikipedia.org/wiki/Tree_sort), anche su computer più lenti, perchè, dovendo ordinare liste sempre più lunghe, prima o poi si raggiunge un punto in cui il primo è più veloce (in termini di tempo) dell'altro.\n                    \n                    Dobbiamo andare a vedere, quindi, _il numero di operazioni richieste per ottenere il r
//# sourceMappingURL=route-AlgoritmiEStruttureDati.chunk.02d3a.esm.js.map