esercizi 19 dic

atrent/2019-12-19/Esercizi.md

+# Esercizi 19 dicembre 2019
+
+## Note prima degli esercizi
+
+- Caricarli su https://upload.di.unimi.it
+
+## I test per esame
+
+**UTILISSIMO!!!**
+
+
+- Prima di poter accedere all'esame vero e proprio, sarete sottoposti a un esercizio di filtro che dovrete essere in grado di risolvere.
+- All'esame non vi sarà consentito scegliere il nome dei file `.go` che dovrete consegnare. Dovete per forza rispettare i nomi stabliti nel tema d'esame.
+- Molte volte, leggere il test è utile per capire il testo dell'esercizio, perchè vi consente di verificare se avete capito davvero le richieste.
+- I commenti all'interno dei vostri file `.go` sono ben accetti se volte spiegare un passaggio poco comprensibile.
+- E' necessario consegnare solamente i file `.go`. Tuttavia, solo i file che riescono a compilare ed essere eseguiti sono quelli che verranno poi valutati. Perciò se avete un file che non compila, mettete a commento la porzione di codice che non vi fa compilare.
+- Ricordatevi sempre di formattare correttamente il vostro file con il comando `go fmt <nomeFile.go>`.
+- Potete caricare più di una volta lo stesso file. La versione che verrà valutata sarà l'ultima che è stata consegnata.
+- State attenti se l'input viene dato da linea di comando o da standard input. 
+
+##### Per estrarre il file tar
+
+All'esame vi verrà fornito un file `.tar`. Per chi non sapesse di cosa si tratta, è un archivio in cui vengono raggruppati insieme più file (immaginate che sia tipo un file `.zip`). E' necessario quindi scompattarlo utilizzando il seguente comando:
+
+```console
+tar xvf <nomeFile.tar>
+```
+Ricordate che le `< >` non sono davvero da scrivere
+
+##### Per testare i file .go da voi creati
+
+```console
+go test
+```
+In teoria, se tutto è andato bene, dovreste vedere stampato a schermo la scritta `PASS`. Se un test ha fallito, vedrete invece la scritta `FAIL`.
+
+Molte volte il test non è completamente automatizzabile, quindi il controllo vero e proprio deve essere fatto da voi "a vista".
+
+Prima di lanciare il comando `go test` è necessario lanciare `go build` per creare l'eseguibile
+
+
+### Esercizio 1 (`somma.go`)
+
+Scrivere una funzione ricorsiva che, avendo in input una lista di numeri, ne calcoli la somma. Gli elementi della lista sono passati per linea di comando.
+
+##### Esempio di esecuzione
+```console
+$./somma 1 2 3 4 5
+
+15
+```
+
+### Spiegazione della soluzione
+
+
+
+**Caso base**: se la lunghezza della lista è 1, allora ovviamente la somma degli elementi di una lista con un solo elemento è l'elemento stesso.
+
+**Passo ricorsivo**:  l'idea è quella di sommare a un dato elemento la somma di tutti gli altri elementi della lista
+Ad esempio, se la lista è `[1,2,3,4,5]`:
+
+`1 + somma[2,3,4,5]`
+
+`1 + 2 + somma[3,4,5]`
+
+e così via
+
+
+
+
+
+
+### Soluzione 1
+
+```go
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"os"
+)
+
+func sommaRec(numeri []int) int {
+	if len(numeri) == 1{
+		return numeri[0]
+	}
+	return sommaRec(numeri[1:]) + numeri[0]
+}
+
+func main(){
+	var numeri []int
+	for i:=1;i<len(os.Args);i++{
+		n,_ :=  strconv.Atoi(os.Args[i])
+		numeri = append(numeri,n)
+	}
+	fmt.Println(sommaRec(numeri))
+}
+```
+
+
+### Soluzione 2
+
+
+```go
+
+package main
+
+import "fmt"
+import "os"
+import "strconv"
+
+func RecSum(s []string) int {
+	n, _ := strconv.Atoi(s[0])
+	if len(s) == 1 {
+		return n
+	} else {
+		return (RecSum(s[1:]) + n)
+	}
+}
+
+func main() {
+	s := (os.Args[1:len(os.Args)])
+	sum := RecSum(s)
+	fmt.Print(sum)
+}
+```
+
+### Soluzione 3
+
+```go
+package main
+
+import (
+  "fmt"
+  "os"
+  "strconv"
+)
+
+func somma (args []string) int {
+  x, _ := strconv.Atoi(args[0])
+  if len(args) == 1 {
+    return x
+  }
+  return x + somma(args[1:])
+}
+
+func main () {
+  fmt.Println(somma(os.Args))
+}
+```
+
+
+### Esercizio 2 (`contenuto.go`)
+Scrivere una funzione ricorsiva che, presa in input una stringa e una lettera da linea di comando, restituisca `Si` se la lettera è contenuta nella stringa o `No` altrimenti.
+
+##### Esempio di esecuzione
+
+```shell=bash
+$ ./contenuto comodino f
+
+No
+```
+
+```shell=bash
+$ ./contenuto comodino m
+
+Si
+```
+
+### Soluzione 1
+
+Trovate cosa c'è di strano dentro questa soluzione
+
+
+```go
+package main
+
+import (
+  "fmt"
+  "os"
+)
+
+func contenuto (string []byte, letter string) string {
+  if string[0] == letter[0] {
+    return "si"
+  }
+  if len(string) == 1 {
+    return "no"
+  }
+  return contenuto(string[1:], letter)
+}
+
+func main () {
+  if len(os.Args) != 3 || len(os.Args[2]) != 1 {
+    fmt.Println("input non valido")
+  } else {
+    s := os.Args[1]
+    var string []byte
+    string = make([]byte, 0)
+    for _, x := range s {
+      string = append(string, byte(x))
+    }
+    fmt.Println(contenuto(string, os.Args[2]))
+  }
+}
+```
+Risposta: è la dichiarazione `var string []byte` 
+
+# Compiti di natale (se avete voglia)
+
+
+### Esercizio 3 (`tartaglia.go`)
+
+Scrivere un programma go che stampi tutti i valori del triangolo di Tartaglia per un certo ordine `n` fornito da linea di comando utilizzando una funzione ricorsiva
+
+https://it.wikipedia.org/wiki/Triangolo_di_Tartaglia
+
+##### Esempio di esecuzione
+```console
+./tartaglia 5
+1
+1 1
+1 2 1
+1 3 3 1
+1 4 6 4 1
+```
+
+### Esercizio 4 (`minimo.go`)
+
+Scrivere una funzione ricorsiva che, avendo in input un array di `n` interi positivi, dia in output l’elemento minimo della lista.
+
+
+##### Esempio di esecuzione
+```console
+$./minimo 2 1 4 3 5
+
+1
+```
+
+### Esercizio 5 (`stampa_inversa.go`)
+ Stampare le linee di un file in ordine inverso, senza usare vettori o cicli.
+
+ ##### Esempio di esecuzione
+ ```console
+ $ ./stampa_inversa input.txt
+
+ ma per seguir virtute e canoscenza
+ fatti non foste a viver come bruti,
+ Considerate la vostra semenza:
+ ```
+
+ dove `input.txt` è, per esempio:
+ ```
+ Considerate la vostra semenza:
+ fatti non foste a viver come bruti,
+ ma per seguir virtute e canoscenza
+ ```
+
+