esercizi 7 nov 2019

parent 25cac0ef
# Esercizi 7 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 \texttt{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 (exp.go)
Dati due interi *n* e *b* in input, verificare se esiste un intero *e*>0 tale per cui vale la seguente formula: $n=b^{e}$.
Se esiste, stampare a schermo il valore *e*, altrimenti stampare un messaggio di errore.
### Esempio di esecuzione
```console
$ ./exp
125
5
3
```
```console
$ ./exp
100
5
Esponente non trovato
```
### Una prima soluzione
```
package main
import "fmt"
func main() {
var n, b int
fmt.Println("inserisci n")
fmt.Scan(&n)
fmt.Println("inserisci b")
fmt.Scan(&b)
potenza:=b
e:=1
if n<=0 || b<=0 { //controllo input in modo dale che n e b siano entrambi positivi
fmt.Println("numeri inseriti non validi")
} else {
if(b != 1) { //controllo che b non sia 1 in modo da evitare un ciclo infinito
for potenza < n {
// for {
potenza *= b
e++
// if ... break // molto meno bello
}
}
if potenza==n {
fmt.Print("n: ",n," è uguale a: ",b,"^",e,"\n")
} else {
fmt.Print("non esiste una e intera tale che: ",b,"^e = ",n,"\n")
}
}
}
```
## Esercizio 2 (dario.go)
Dario, che frequenta la prima elementare, non ha ancora imparato a eseguire le sottrazioni. Infatti, quando deve decrementare un numero, esegue la seguente mossa:
+ se l'ultima cifra del numero da decrementare **non** è zero, allora viene decrementata correttamente. Ad esempio, se il numero è 123, diventa 122.
+ se l'ultima cifra è zero, allora viene eliminata. Ad esempio, 120 diventa 12.
Dato in input un intero *n*>1 e un numero *d*>0, calcolare *(n dariosottrazione d)* usando il metodo appena indicato.
### Esempio di esecuzione
```console
$./dario
612
4
60
```
```console
$./dario
10
2
-2
```
*Nota*: i passaggi che sono stati eseguiti sono i seguenti:
<center>612 -> 611 -> 610 -> 61 -> 60</center>
### Una possibile soluzione
```
package main
import "fmt"
func main(){
var n,d int
fmt.Println("Inserisci n")
fmt.Scan(&n)
fmt.Println("Inserisci d")
fmt.Scan(&d)
if n>1 && d>0{
for i:=0; i<d; i++{
if (n%10==0 && n!=0) {
fmt.Println(n/10)
n=n/10
} else{
fmt.Println(n-1)
n=n-1
}
}
} else {
fmt.Println("Valori non validi")
}
}
```
## Esercizio 3 (vocali.go)
Data una stringa in input, contare quante vocali sono contenute in essa.
*Cosa succede se la stringa non fosse di soli caratteri minuscoli? Cercate una funzione adeguata all'interno del modulo "strings" per non dover eseguire 10 controlli differenti*
### Esempio di esecuzione
```console
$./vocali
informatica
5
```
```console
$./vocali
mInorfAtica
5
```
```
$ ./vocali < vocali.go
```
### Ipotesi soluzione
```
package main
import "fmt"
import "strings"
func main (){
var s string
var a,e,i,o,u int
fmt.Scan(&s)
a=strings.Count(s, "a")+strings.Count(s, "A")
e=strings.Count(s, "e")+strings.Count(s, "E")
i=strings.Count(s, "i")+strings.Count(s, "I")
o=strings.Count(s, "o")+strings.Count(s, "O")
u=strings.Count(s, "u")+strings.Count(s, "U")
fmt.Println("a=",a,"\n","e=",e,"\n","i=",i,"\n","o=",o,"\n","u=",u,"\n",)
}
```
```
package main
import "fmt"
import "strings"
func main() {
var s, voc string
fmt.Scan(&s)
voc = "AEIOU"
for i:=0; i<5; i++ {
fmt.Print(string(voc[i]), ": ", strings.Count(s, string(voc[i]))+strings.Count(s, strings.ToLower(string(voc[i]))), "\n")
}
}
```
```
package main
import (
"fmt"
"strings"
)
func main(){
var s string;
var contaVocali int;
fmt.Print("Inserisci una stringa:");
fmt.Scan(&s);
fmt.Print(s);
s = strings.ToLower(s);
for _, c := range s {
if c=='a' || c=='e' || c=='i' || c=='o' || c=='u'{
contaVocali++;
}
}
fmt.Println();
fmt.Println("Ho trovato", contaVocali, "vocali");
}
```
## Esercizio 4 (pir1.go)
Dato un intero *h*>0 in input, stampare a schermo una piramide di asterischi avente altezza *h*.
### Esempio di esecuzione
```console
$./pir1
4
*
**
***
****
```
### Ipotesi soluzione
```
package main
import "fmt"
func main(){
var h int
fmt.Scan(&h)
for i:=1;i<=h;i++{
for u:=1; u<=i; u++{
fmt.Print("*")
}
fmt.Println()
}
}
```
```
package main
import "fmt"
func main() {
var n int
var s string
s = "*"
fmt.Println("Inserire altezza")
fmt.Scan(&n)
for i:=0;i<n;i++ {
fmt.Println(s)
s += "*"
}
}
```
## Esercizio 5 (pir2.go)
Dato un intero *h*>0 in input, stampare a schermo una piramide di altezza *h* composta unicamente da linee aventi un numero dispari crescente di asterischi.
### Esempio di esecuzione
```console
$./pir2
4
*
***
*****
*******
```
## Esercizio 6 (pir3.go)
Dato un intero *h* in input, stampare a schermo una piramide di altezza *h* composta unicamente da linee aventi un numero dispari crescente di asterischi.
*Nota* che se *h* è 0, la priamide non possiede alcun asterisco. Invece, se *h* è negativo, la piramide risulta "rovesciata"
### Esempio di esecuzione
```console
$./pir3
4
*
***
*****
*******
```
```console
$./pir3
-4
*******
*****
***
*
```
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