- 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
packagemain
import(
"fmt"
"strconv"
"os"
)
funcsommaRec(numeri[]int)int{
iflen(numeri)==1{
returnnumeri[0]
}
returnsommaRec(numeri[1:])+numeri[0]
}
funcmain(){
varnumeri[]int
fori:=1;i<len(os.Args);i++{
n,_:=strconv.Atoi(os.Args[i])
numeri=append(numeri,n)
}
fmt.Println(sommaRec(numeri))
}
```
### Soluzione 2
```go
packagemain
import"fmt"
import"os"
import"strconv"
funcRecSum(s[]string)int{
n,_:=strconv.Atoi(s[0])
iflen(s)==1{
returnn
}else{
return(RecSum(s[1:])+n)
}
}
funcmain(){
s:=(os.Args[1:len(os.Args)])
sum:=RecSum(s)
fmt.Print(sum)
}
```
### Soluzione 3
```go
packagemain
import(
"fmt"
"os"
"strconv"
)
funcsomma(args[]string)int{
x,_:=strconv.Atoi(args[0])
iflen(args)==1{
returnx
}
returnx+somma(args[1:])
}
funcmain(){
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
packagemain
import(
"fmt"
"os"
)
funccontenuto(string[]byte,letterstring)string{
ifstring[0]==letter[0]{
return"si"
}
iflen(string)==1{
return"no"
}
returncontenuto(string[1:],letter)
}
funcmain(){
iflen(os.Args)!=3||len(os.Args[2])!=1{
fmt.Println("input non valido")
}else{
s:=os.Args[1]
varstring[]byte
string=make([]byte,0)
for_,x:=ranges{
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