esercizi 14 novembre

parent b4b2565e
# 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')
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