- una struttura `Rettangolo`, con campi base e altezza, in quest'ordine, di tipo int
- un **metodo**`String()` per Rettangolo che restituisce il disegno del rettangolo, pieno e disegnato con '.', terminato da un new-line ('\n'). Ad esempio, per un Rettangolo di base 5 e altezza 3, il metodo deve restituire la seguente stringa:
```
.....
.....
.....
```
Se però la base o l'altezza del rettangolo sono uguali a 0, il metodo String deve restituire il messaggio "rettangolo degenere".
- una funzione `main()` che, dati due numeri naturali come
argomenti sulla linea di comando, emetta nel flusso d'uscita il disegno del rettangolo che ha quei valori per la base e l'altezza (utilizzando il metodo String).
NB: vedi `tar` per i test
nomefile: rettangolo.go
## Esercizio "segmento" (T)
Scrivere un programma `segmento.go`, dotato di:
- una struttura `Segmento`, con campi
- estremi byte
- interno byte
- orizzontale bool (*false* sta per verticale)
- lunghezza int
dichiarati in quest'ordine
- un **metodo**`String()` per Segmento che restituisce una rappresentazione grafica del segmento. Ad esempio un segmento\
seg := Segmento{'*', '-', true, 5} \
è rappresentato graficamente dalla stringa `*---*`
- un **metodo**`allunga(n int)` per *Segmento che incrementa di n la lunghezza del segmento (o la accorcia se n è negativo)
- una funzione `main()` che legge da standard input, separati da spazi, in quest'ordine:
- il carattere per gli estremi
- il carattere interno
- true o false per orizzontale o verticale
- la lunghezza del segmento
ed emette nel flusso d'uscita la rappresentazione grafica del segmento con quelle caratteristiche. Poi allunga quello stesso segmento di 3 e di nuovo ne emette nel flusso d'uscita la rappresentazione grafica. Infine modifica il valore del capo orizzontale e di nuovo ne emette nel flusso d'uscita la rappresentazione grafica.
NB: vedi `tar` per i test
nomefile: segmento.go
# Printf e Scanf (T)
Vedi le specifiche per il programma `readCSV.go` nel `.tar`, dir `readCSV`
nomefile: readCSV.go
# []byte e []rune (T)
Vedi le specifiche per il programma `repInPlace.go` nel `.tar` , dir `repInPlace`
nomefile: repInPlace.go
# Ricorsione
**Nota**. Per ogni problema, identificare il o i *casi base* e il o i *casi ricorsivi*, poi passare all'implementazione.
## Esercizio "fattoriale"
Scrivere un programma `fattoriale.go`, dotato di:
- una funzione ricorsiva `func fattoriale(n int) int`
che calcola il fattoriale del numero n passato come parametro,
- una funzione `main()` che, dato un numero naturale come
argomento sulla linea di comando, emetta nel flusso d'uscita il fattoriale del numero dato.
Dato un numero naturale *n*, il suo fattoriale, indicato con *n*!, è così definito:
- 0! = 1
- per *n* > 0, *n*! = *n** (*n*-1)!
nomefile: fattoriale.go
## Esercizio "somma"
Scrivere un programma `sommaRicorsiva.go`, dotato di:
- una funzione ricorsiva `func recursiveSum(list []int) int`
che calcola la somma degli interi della slice *list* passata come parametro,
- una funzione `main()` che legge da standard input (ctrl D per terminare) una lista di numeri interi ed emette nel flusso d'uscita la somma dei numeri letti.
La somma di una lista vuota è 0.
nomefile: sommaRicorsiva.go
## Esercizio "palindromo"
Scrivere un programma `palindromo.go`, dotato di:
- una funzione ricorsiva `isPalindrome(s string) bool` che stabilisce se la stringa *s* è palindroma
- una funzione `main()` che, data una stringa *s* come argomento sulla linea di comando, emetta nel flusso d'uscita il messaggio "s è palindroma", se *s*
è palindroma, e "s non è palindroma" altrimenti.
La stringa vuota e le stringhe di lunghezza 1 sono considerate palindrome.
nomefile: palindromo.go
## Esercizio "max" (T)
Scrivere un programma `max.go`, dotato di:
- una funzione ricorsiva `recursiveMax(list []int) int` che restituisca il massimo tra i valori di *list*
- una funzione `main()` che legga da standard input (ctrl D per terminare) una lista di numeri interi (che posono essere positivi, negativi, nulli) ed emetta nel flusso d'uscita il massimo tra i numeri letti.
Il massimo di una sequenza vuota non è definito, quindi assumiamo (non è richiesto che vengano fatti controlli) che la sequenza abbia sempre almeno un numero.
Può essere comodo definire una funzione di supporto
-`func greater(m, n int) int`\
che restituisce il maggiore tra m e n.
NB: vedi `tar` per i test
nomefile: max.go
## Esercizio supplementare "conta" (facoltativo)
Scrivere un programma conta.go, dotato di:
- una funzione ricorsiva `recursiveCount(el int, list []int) int` che restituisca il numero di volte che *el* appare tra i valori di *list*
- una funzione `main()` che legga da standard input (ctrl D per terminare) una lista di numeri interi (che posono essere positivi, negativi, nulli) ed emetta nel flusso d'uscita quante volte il primo numero letto è ripetuto nella sequenza dei successivi numeri letti.
- una funzione ricorsiva `righello(n int)` che, data la dimensione di un righello, emetta nel flusso d'uscita un righello della dimensione data
- una funzione main() che, data la dimensione come argomento sulla linea di comando, produca il righello corrispondente
La dimensione può essere 0, nel qual caso il programma non emette nulla.
Per la definizione di "righello" si legga con attenzione quanto segue:
- chiamiamo "tacca" di lunghezza N una sequenza di N caratteri "-" seguiti da "a-capo"
- chiamiamo "righello" di dimensione M > 0 una tacca lunga M preceduta e seguita da un righello di dimensione M - 1, assumendo per convenzione che un righello di dimensione 0 non contenga alcuna tacca (o altro righello)
Ad esempio, un righello di dimensione 1 è:
```
-
```
ossia è una tacca (preceduta e seguita da null'altro);
un righello di dimensione 2 è:
```
-
--
-
```
infatti è dato da un righello di dimensione 1 seguito da una tacca
lunga 2 e quindi da un righello di dimensione 1;
un righello di dimensione 3 è:
```
-
--
-
---
-
--
-
```
di nuovo, infatti, osserviamo un righello di dimensione 2, seguito da una
tacca di lunghezza 3 e quindi ancora da un righello di dimensione 2.
