esercizi 19 dic

parent da9a2e98
# 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
```
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment