esercizi 14 novembre

atrent/2019-11-14/Esercizi.md

+# Esercizi 14 novembre 2019
+
+## Note prima degli esercizi
+
+- Caricarli su https://upload.di.unimi.it
+
+- Molte volte nel testo dell'esercizio si specificano dei vincoli sull'input. Occorre verificarne sempre la veridicità. Nel caso in cui l'input inserito non rispetti il vincolo, stampare un messaggio di errore e chiederne il reinserimento, fino a quando non viene fornito un input valido. Ad esempio, se il programma *pippo.go* attende in input un numero pari, un possibile scenario potrebbe essere il seguente:
+
+```console
+$./pippo
+Inserire un numero n pari:
+3
+Numero non valido
+Inserire un numero n pari:
+5
+Numero non valido
+Inserire un numero n pari:
+2
+```
+
+## Esercizio 1 (contare righe)
+
+Creare programma che conta le righe di testo che vengono immesse a stdin. (ispirazione 'wc')
+
+```
+scanner := bufio.NewScanner(os.Stdin)
+for scanner.Scan() {
+	line = scanner.Text()
+}
+```
+
+
+Una prima soluzione:
+
+```
+package main
+
+import (
+	"fmt"
+	"bufio"
+	"os"
+)
+
+func main() {
+	var linea int
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan () {
+		// programmatore scaltro 1.0
+		//_ = scanner.Text()
+
+		// programmatore flusso di coscienza
+		//line := scanner.Text()
+		//_=line
+		linea++
+	}
+	fmt.Println("hai inserito",linea,"righe")
+}
+```
+
+
+### Variazione sul tema
+
+Modificare il programma precedente in modo che stampi le righe precedute dal loro numero progressivo.
+
+
+## Esercizio 2 (trasformare caratteri)
+
+Creare programma che trasforma i caratteri dell'input, ad esempio da minuscole a maiuscole. (ispirazione 'tr')
+
+
+Prima versione:
+
+```
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+	var text string
+
+	//fmt.Println("inserire testo:") // tolgo per non sporcare output
+
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		line := scanner.Text()
+		line = strings.ToUpper(line)
+		text += "\n" + line
+	}
+	//fmt.Print("\n \n", "testo in capslock:") // idem
+	fmt.Println(text)
+}
+```
+
+
+Versione semplificata:
+
+```
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		fmt.Println(strings.ToUpper(scanner.Text()));
+	}
+}
+```
+
+
+
+## Esercizio 3 (contare cose)
+
+Creare programma che conta le parole in un testo che viene immesso a stdin. (ispirazione ancora 'wc')
+
+Primo tentativo (non perfetto):
+
+```
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+func main() {
+	var parole int
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		line := scanner.Text()
+		for _, r := range line {
+			if r == ' ' { // così però conto solo gli spazi e non il generico whitespace (cfr. unicode.IsSpace())
+				parole++
+			}
+		}
+	}
+	fmt.Println("\nparole =", parole)
+}
+```
+
+
+Secondo tentativo, funziona:
+
+```
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+	var conta int
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		conta += len(strings.Fields(scanner.Text()))
+	}
+	fmt.Println(conta)
+}
+```
+
+Versione a "pattern":
+
+```
+package main
+
+import (
+	"fmt"
+	"os"
+	"bufio"
+	)
+
+func main () {
+	scanner := bufio.NewScanner(os.Stdin)
+	// per niente copiato dall'esempio della documentazione:
+	// (ma forse ora compreso)
+	scanner.Split(bufio.ScanWords)
+	count := 0
+	for scanner.Scan() {
+		count++
+	}
+	fmt.Println(count)
+}
+```
+
+
+## Esercizio 4 (contare cose)
+
+Creare programma che conta le parole in un testo che viene immesso a stdin, ma solo quelle che iniziano per vocale. (ispirazione 'grep' e 'wc')
+
+Prima soluzione:
+```
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+func main() {
+
+	scanner := bufio.NewScanner(os.Stdin)
+
+	scanner.Split(bufio.ScanWords)
+	count := 0
+	for scanner.Scan() {
+		x := scanner.Text()
+		switch string(x[0]) {
+		case "a", "e", "i", "o", "u":
+			count++
+		}
+
+	}
+
+	fmt.Println(count)
+
+}
+```
+
+Seconda soluzione:
+```
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+	scanner := bufio.NewScanner(os.Stdin)
+	// per niente copiato dall'esempio della documentazione:
+	scanner.Split(bufio.ScanWords)
+	count := 0
+	voc := "aeiou"
+	for scanner.Scan() {
+		if strings.IndexAny(strings.ToLower(scanner.Text()), voc) == 0 {
+			count++
+		}
+	}
+	fmt.Println(count)
+}
+
+```
+
+## Esercizio 5 (misurare cose)
+
+Creare programma che misura la distanza media/min/max tra le 'a' successive in un testo che viene immesso a stdin.
+
+#### Nota sull'esercizio sottostante
+Al posto di inserire il valore *min* in modo esplicito, è più comodo utilizzare una costante presa direttamente dalla libreria (https://golang.org/pkg/math/) che indichi tale valore. Nello specifico, in questo caso la costante è MaxInt32 (oppure MaxInt64, dipende)
+```
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+	var somma, c, n, min, max int
+	var media float64
+	min = 9223372036854775807
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Split(bufio.ScanRunes)
+	for scanner.Scan() {
+		rune := scanner.Text()
+		c++
+		rune = strings.ToLower(rune)
+		if rune == "a" {
+			if min > c {
+				min = c
+			}
+			if max < c {
+				max = c
+			}
+			somma += c
+			c = 0
+			n++
+		}
+	}
+	media = float64(somma) / float64(n)
+	fmt.Println("distanza media:", media, "distanza minima:", min, "distanza massima:", max)
+}
+```
+
+
+## Esercizio 6 (trasformare input)
+
+Creare programma che scrive le righe che riceve in input ribaltandole (es. 'ciao' diventa 'oaic'). (ispirazione 'rev')
+
+
+## Esercizio 7 (trasformare input)
+
+Creare programma che scrive le righe che riceve in input ma solo dal carattere 10 a 30. (ispirazione 'cut')
+
+
+
+
+