Differences
This shows you the differences between two versions of the page.
| — |
pub:labprog:2020-10-22 [2020/10/24 13:58] (current) atrent created |
||
|---|---|---|---|
| Line 1: | Line 1: | ||
| + | ====== Note lezione (22/10/2020) ====== | ||
| + | |||
| + | |||
| + | (ATTENZIONE che è un copia e incolla dalla sessione collaborativa con l'editor, minimamente riformattato, va preso "cum grano salis") | ||
| + | |||
| + | 🌈 | ||
| + | |||
| + | ⚡ | ||
| + | |||
| + | 🔋 | ||
| + | |||
| + | ⏰ | ||
| + | |||
| + | **Attenzione a non sovrascrivere il testo esistente** | ||
| + | |||
| + | per Gobby: | ||
| + | atrent.it:11778 | ||
| + | |||
| + | ===== MEMO ===== | ||
| + | |||
| + | * scrivete tanto codice e fate saltar fuori gli errori | ||
| + | * usate molto il prompt | ||
| + | * non abbiate paura di fare domande (o scrivere commenti) | ||
| + | |||
| + | ===== TODO ===== | ||
| + | |||
| + | * (POSTPONED) dobbiamo decidere un editor collaborativo | ||
| + | * PATH | ||
| + | |||
| + | ===== Barzelletta sul testing ===== | ||
| + | |||
| + | |||
| + | “A QA engineer walks into a bar. Orders a beer. Orders 0 beers. Orders 999999999 beers. Orders a lizard. Orders -1 beers. Orders a sfdeljknesv.” | ||
| + | |||
| + | ===== Esercizi proposti ===== | ||
| + | |||
| + | |||
| + | ==== ESERCIZIO 0 ==== | ||
| + | |||
| + | |||
| + | Scrivere un programma Go condizioni.go che testa, una a una, le seguenti condizioni. | ||
| + | Implementarne una alla volta, testarla su almeno due input (uno che la verifica | ||
| + | e uno che la falsifica), e solo poi procedere alla successiva. | ||
| + | Il programma legge un valore (del tipo indicato) da tastiera e stampa "true" o "false" a seconda che la condozione sia verificata o no. | ||
| + | |||
| + | 1. a int uguale a 10 | ||
| + | 1. b int diverso da 10 | ||
| + | 1. c int diverso da 10 e da 20 | ||
| + | 1. d int diverso da 10 o da 20 | ||
| + | 1. e int maggiore o uguale a 10 | ||
| + | 1. f int compreso tra 10 e 20, nell'intervallo [10,20] | ||
| + | 1. g int compreso tra 10 e 20, nell'intervallo (10,20] | ||
| + | 1. h int compreso tra 10 e 20, nell'intervallo [10,20) | ||
| + | 1. i int esterno all'intervallo[10,20] | ||
| + | 1. j int tra 10 e 20 (nell'intervallo [10,20]) o tra 30 e 40 ([30,40]) | ||
| + | 1. k int multiplo di 4 ma non di 100 | ||
| + | 1. l int dispari e compreso tra 0 e 100 ([0,100]) | ||
| + | 1. x float64 "vicino" a 10 (entro 10^-6) | ||
| + | |||
| + | === soluzioni proposte === | ||
| + | |||
| + | |||
| + | Soluzione "mono-variabile": | ||
| + | ```go | ||
| + | package main | ||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var sempreLaStessa int | ||
| + | fmt.Print("Inserisci input: ") | ||
| + | fmt.Scan(&sempreLaStessa) | ||
| + | if sempreLaStessa == 10 { | ||
| + | fmt.Println("La variabile è uguale a 10!") | ||
| + | } | ||
| + | } | ||
| + | ``` | ||
| + | |||
| + | ```go | ||
| + | func main() { | ||
| + | var n int | ||
| + | var x float64 | ||
| + | fmt.Print("Inserisci un numero intero: ") | ||
| + | fmt.Scan(&n) | ||
| + | fmt.Print("Inserisci un numero con la virgola: ") | ||
| + | fmt.Scan(&x) | ||
| + | |||
| + | if n == 10 { | ||
| + | fmt.Println("a: true") | ||
| + | } else { | ||
| + | fmt.Println("a: false") | ||
| + | } | ||
| + | |||
| + | if n != 10 { | ||
| + | fmt.Println("b: true") | ||
| + | } else { | ||
| + | fmt.Println("b: false") | ||
| + | } | ||
| + | |||
| + | if n != 10 && n != 20 { | ||
| + | fmt.Println("c: true") | ||
| + | } else { | ||
| + | fmt.Println("c: false") | ||
| + | } | ||
| + | |||
| + | if n != 10 || n != 20 { | ||
| + | fmt.Println("d: true") | ||
| + | } else { | ||
| + | fmt.Println("d: false") | ||
| + | } | ||
| + | |||
| + | if n >= 10 { | ||
| + | fmt.Println("e: true") | ||
| + | } else { | ||
| + | fmt.Println("e: false") | ||
| + | } | ||
| + | |||
| + | if n >= 10 && n <= 20 { | ||
| + | fmt.Println("f: true") | ||
| + | } else { | ||
| + | fmt.Println("f: false") | ||
| + | } | ||
| + | |||
| + | if n > 10 && n <= 20 { | ||
| + | fmt.Println("g: true") | ||
| + | } else { | ||
| + | fmt.Println("g: false") | ||
| + | } | ||
| + | |||
| + | if n >= 10 && n < 20 { | ||
| + | fmt.Println("h: true") | ||
| + | } else { | ||
| + | fmt.Println("h: false") | ||
| + | } | ||
| + | |||
| + | if n < 10 || n > 20 { | ||
| + | fmt.Println("i: true") | ||
| + | } else { | ||
| + | fmt.Println("i: false") | ||
| + | } | ||
| + | |||
| + | if n > 10 && n < 20 || n > 30 && n < 40 { | ||
| + | fmt.Println("j: true") | ||
| + | } else { | ||
| + | fmt.Println("j: false") | ||
| + | } | ||
| + | |||
| + | if n%4 == 0 && !(n%100 == 0) { | ||
| + | fmt.Println("k: true") | ||
| + | } else { | ||
| + | fmt.Println("k: false") | ||
| + | } | ||
| + | |||
| + | if n%2 != 0 && n >= 0 && n <= 100 { | ||
| + | fmt.Println("l: true") | ||
| + | } else { | ||
| + | fmt.Println("l: false") | ||
| + | } | ||
| + | |||
| + | if math.Abs(x-10) < 1e-6 { | ||
| + | fmt.Println("x: true") | ||
| + | } else { | ||
| + | fmt.Println("x: false") | ||
| + | } | ||
| + | |||
| + | } | ||
| + | |||
| + | ``` | ||
| + | |||
| + | |||
| + | Soluzioni "multi-variabile": | ||
| + | 10 | ||
| + | ```go | ||
| + | package main | ||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var a, b, c, d, e int | ||
| + | fmt.Print("Inserisci a: ") | ||
| + | fmt.Scan(&a) | ||
| + | if a == 10 { | ||
| + | fmt.Println("a è uguale a 10!") | ||
| + | } | ||
| + | fmt.Print("Inserisci b: ") | ||
| + | fmt.Scan(&b) | ||
| + | if b != 10 { | ||
| + | fmt.Println("b è diverso da 10¿") | ||
| + | } | ||
| + | fmt.Print("Inserisci c: ") | ||
| + | fmt.Scan(&c) | ||
| + | if c != 10 && c != 20 { | ||
| + | fmt.Println("c è diverso da 10 e da 20") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | ``` | ||
| + | ``` go | ||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main(){ | ||
| + | var a, b, c int | ||
| + | | ||
| + | fmt.Print("Inserire a--> ") | ||
| + | fmt.Scan(&a) | ||
| + | | ||
| + | if a == 10 { | ||
| + | fmt.Print("True") | ||
| + | } else { | ||
| + | fmt.Print("false") | ||
| + | } | ||
| + | | ||
| + | fmt.Print("Inserire b--> ") | ||
| + | fmt.Scan(&b) | ||
| + | | ||
| + | if b != 10 { | ||
| + | fmt.Print("True") | ||
| + | } else { | ||
| + | fmt.Print("False") | ||
| + | } | ||
| + | | ||
| + | fmt.Print("Inserire c--> ") | ||
| + | fmt.Scan(&c) | ||
| + | | ||
| + | if c!=10 && c!=20 { | ||
| + | fmt.Print("True") | ||
| + | } else { | ||
| + | fmt.Print("False") | ||
| + | } | ||
| + | } | ||
| + | ``` | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | ``` go | ||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | import "math.abs" | ||
| + | func main(){ | ||
| + | var x float64 | ||
| + | math.abs(x-) | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | ``` | ||
| + | |||
| + | ``` go | ||
| + | |||
| + | //non li ho testati | ||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | import "math" | ||
| + | |||
| + | func main() { | ||
| + | var a int | ||
| + | var x float64 | ||
| + | |||
| + | fmt.Print("A: ") | ||
| + | fmt.Scan(&a) | ||
| + | if a==10{ | ||
| + | fmt.Println("A verificata") | ||
| + | } else { | ||
| + | fmt.Println("A non verificata") | ||
| + | } | ||
| + | |||
| + | fmt.Print("B: ") | ||
| + | fmt.Scan(&a) | ||
| + | if a!=10{ | ||
| + | fmt.Println("B verificata") | ||
| + | } else { | ||
| + | fmt.Println("B non verificata") | ||
| + | } | ||
| + | |||
| + | fmt.Print("C: ") | ||
| + | fmt.Scan(&a) | ||
| + | if a!=10 && a!=20{ | ||
| + | fmt.Println("C verificata") | ||
| + | } else { | ||
| + | fmt.Println("C non verificata") | ||
| + | } | ||
| + | |||
| + | fmt.Print("D: ") | ||
| + | fmt.Scan(&a) | ||
| + | fmt.Println("D verificata") | ||
| + | |||
| + | fmt.Print("E: ") | ||
| + | fmt.Scan(&a) | ||
| + | if a>=10{ | ||
| + | fmt.Println("E verificata") | ||
| + | } else { | ||
| + | fmt.Println("E non verificata") | ||
| + | } | ||
| + | |||
| + | fmt.Print("F: ") | ||
| + | fmt.Scan(&a) | ||
| + | if a>=10 && a<=20{ | ||
| + | fmt.Println("F verificata") | ||
| + | } else { | ||
| + | fmt.Println("F non verificata") | ||
| + | } | ||
| + | |||
| + | fmt.Print("G: ") | ||
| + | fmt.Scan(&a) | ||
| + | if a>10 && a<=20{ | ||
| + | fmt.Println("G verificata") | ||
| + | } else { | ||
| + | fmt.Println("G non verificata") | ||
| + | } | ||
| + | |||
| + | fmt.Print("H: ") | ||
| + | fmt.Scan(&a) | ||
| + | if a>=10 && a<20{ | ||
| + | fmt.Println("H verificata") | ||
| + | } else { | ||
| + | fmt.Println("H non verificata") | ||
| + | } | ||
| + | |||
| + | fmt.Print("I: ") | ||
| + | fmt.Scan(&a) | ||
| + | if a<10 || a>20{ | ||
| + | fmt.Println("I verificata") | ||
| + | } else { | ||
| + | fmt.Println("I non verificata") | ||
| + | } | ||
| + | |||
| + | fmt.Print("J: ") | ||
| + | fmt.Scan(&a) | ||
| + | if (a>=10 && a<=20) || (a>=30 && a<=40){ | ||
| + | fmt.Println("J verificata") | ||
| + | } else { | ||
| + | fmt.Println("J non verificata") | ||
| + | } | ||
| + | |||
| + | fmt.Print("K: ") | ||
| + | fmt.Scan(&a) | ||
| + | if a%4==0 && a%100!=0{ | ||
| + | fmt.Println("K verificata") | ||
| + | } else { | ||
| + | fmt.Println("K non verificata") | ||
| + | } | ||
| + | |||
| + | fmt.Print("L: ") | ||
| + | fmt.Scan(&a) | ||
| + | if (a+1)%2 == 0 && (a>=0 && a<=100){ | ||
| + | fmt.Println("L verificata") | ||
| + | } else { | ||
| + | fmt.Println("L non verificata") | ||
| + | } | ||
| + | |||
| + | fmt.Print("X: ") | ||
| + | fmt.Scan(&x) | ||
| + | |||
| + | // if math.Abs(a-float64(10)) < 10E-6 { // era un errore di copiaeincolla | ||
| + | if math.Abs(x-float64(10)) < 1E-6 { | ||
| + | | ||
| + | fmt.Println("X verificata") | ||
| + | } else { | ||
| + | fmt.Println("X non verificata") | ||
| + | } | ||
| + | | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | ``` | ||
| + | |||
| + | ``` go | ||
| + | |||
| + | package main | ||
| + | |||
| + | import ( "fmt" | ||
| + | "math") | ||
| + | |||
| + | func main() { | ||
| + | var x float64 | ||
| + | fmt.Scan(&x) | ||
| + | |||
| + | if math.Abs(x) < 10 + (1E-6) && math.Abs(f) > 10 -(1E-6){ | ||
| + | fmt.Println("true") | ||
| + | }else{ | ||
| + | fmt.Println("false") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | //// | ||
| + | //ho evitato di fare tutti gli if per concentrarmi sulle condizioni | ||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var a int | ||
| + | var b float64 | ||
| + | fmt.Scan(&a) | ||
| + | fmt.Println("a)", a == 10) | ||
| + | fmt.Println("b)", a != 10) | ||
| + | fmt.Println("c)", (a != 10) && (a !=20)) | ||
| + | fmt.Println("d)", (a != 10) || (a !=20)) | ||
| + | fmt.Println("e)", a >= 10) | ||
| + | fmt.Println("f)", (a >= 10) && (a <= 20)) | ||
| + | fmt.Println("g)", (a > 10) && (a <= 20)) | ||
| + | fmt.Println("h)", (a >= 10) && (a < 20)) | ||
| + | fmt.Println("i)", (a < 10) && (a > 20)) | ||
| + | fmt.Println("j)", (a >= 10 && a <= 20) || (a >= 30 && a <= 40)) | ||
| + | fmt.Println("k)", (a%4 == 0) && (a%100 != 0)) | ||
| + | fmt.Println("l)", (a%2 == 0) && (a >= 0 && a | ||
| + | <= 100)) | ||
| + | fmt.Scan(&b) | ||
| + | fmt.Println("x)", (b >= 10 - 10E-6) && (b <= 10 + 10E-6)) //:) | ||
| + | } | ||
| + | |||
| + | /// | ||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | |||
| + | var num int | ||
| + | |||
| + | // 1 | ||
| + | |||
| + | fmt.Print("Inserire un numero: ") | ||
| + | fmt.Scan(&num) | ||
| + | |||
| + | fmt.Print("Il numero è uguale a 10: ") | ||
| + | if num == 10 { | ||
| + | fmt.Println("true") | ||
| + | }else{ | ||
| + | fmt.Println("false") | ||
| + | } | ||
| + | |||
| + | // 2 | ||
| + | |||
| + | fmt.Print("Inserire un numero: ") | ||
| + | fmt.Scan(&num) | ||
| + | |||
| + | fmt.Print("Il numero è diverso da 10: ") | ||
| + | if num != 10 { | ||
| + | fmt.Println("true") | ||
| + | }else{ | ||
| + | fmt.Println("false") | ||
| + | } | ||
| + | |||
| + | // 3 | ||
| + | |||
| + | fmt.Print("Inserire un numero: ") | ||
| + | fmt.Scan(&num) | ||
| + | |||
| + | fmt.Print("Il numero è diverso da 10 e da 20: ") | ||
| + | if num != 10 && num != 20{ | ||
| + | fmt.Println("true") | ||
| + | }else{ | ||
| + | fmt.Println("false") | ||
| + | } | ||
| + | |||
| + | // 4 | ||
| + | |||
| + | fmt.Print("Inserire un numero: ") | ||
| + | fmt.Scan(&num) | ||
| + | |||
| + | fmt.Print("Il numero è diverso da 10 o da 20: ") | ||
| + | if num != 10 || num != 20 { | ||
| + | fmt.Println("true") | ||
| + | }else{ | ||
| + | fmt.Println("false") | ||
| + | } | ||
| + | |||
| + | // 5 | ||
| + | |||
| + | fmt.Print("Inserire un numero: ") | ||
| + | fmt.Scan(&num) | ||
| + | |||
| + | fmt.Print("Il numero è maggiore o uguale a 10: ") | ||
| + | if num >= 10 { | ||
| + | fmt.Println("true") | ||
| + | }else{ | ||
| + | fmt.Println("false") | ||
| + | } | ||
| + | |||
| + | // 6 | ||
| + | |||
| + | fmt.Print("Inserire un numero: ") | ||
| + | fmt.Scan(&num) | ||
| + | |||
| + | fmt.Print("Il numero è compreso tra 10 e 20 ( estremi inclusi ): ") | ||
| + | if num >= 10 && num <= 20 { | ||
| + | fmt.Println("true") | ||
| + | }else{ | ||
| + | fmt.Println("false") | ||
| + | } | ||
| + | |||
| + | // 7 | ||
| + | |||
| + | fmt.Print("Inserire un numero: ") | ||
| + | fmt.Scan(&num) | ||
| + | |||
| + | fmt.Print("Il numero è compreso tra 10 e 20 (10 escluso): ") | ||
| + | if num > 10 && num <= 20 { | ||
| + | fmt.Println("true") | ||
| + | }else{ | ||
| + | fmt.Println("false") | ||
| + | } | ||
| + | |||
| + | // 8 | ||
| + | |||
| + | fmt.Print("Inserire un numero: ") | ||
| + | fmt.Scan(&num) | ||
| + | |||
| + | fmt.Print("Il numero è compreso tra 10 e 20 (20 escluso): ") | ||
| + | if num >= 10 && num < 20 { | ||
| + | fmt.Println("true") | ||
| + | }else{ | ||
| + | fmt.Println("false") | ||
| + | } | ||
| + | |||
| + | // 9 | ||
| + | |||
| + | fmt.Print("Inserire un numero: ") | ||
| + | fmt.Scan(&num) | ||
| + | |||
| + | fmt.Print("Il numero è esterno all'intervallo [10,20]: ") | ||
| + | if num < 10 && num > 20 { | ||
| + | fmt.Println("true") | ||
| + | }else{ | ||
| + | fmt.Println("false") | ||
| + | } | ||
| + | |||
| + | // 10 | ||
| + | |||
| + | fmt.Print("Inserire un numero: ") | ||
| + | fmt.Scan(&num) | ||
| + | |||
| + | fmt.Print("Il numero compreso tra 10 e 20 oppure tra 30 e 40 (estremi inclusi): ") | ||
| + | if ( num >= 10 && num <= 20 ) || ( num >= 30 && num <= 40 ){ | ||
| + | fmt.Println("true") | ||
| + | }else{ | ||
| + | fmt.Println("false") | ||
| + | } | ||
| + | |||
| + | // 11 | ||
| + | |||
| + | fmt.Print("Inserire un numero: ") | ||
| + | fmt.Scan(&num) | ||
| + | |||
| + | fmt.Print("Il numero è multiplo di 4 ma non di 100: ") | ||
| + | if num % 4 == 0 && num % 100 != 0 { | ||
| + | fmt.Println("true") | ||
| + | }else{ | ||
| + | fmt.Println("false") | ||
| + | } | ||
| + | |||
| + | // 12 | ||
| + | |||
| + | fmt.Print("Inserire un numero: ") | ||
| + | fmt.Scan(&num) | ||
| + | |||
| + | fmt.Print("Il numero è dispari e compreso tra 0 e 100 (estremi inclusi): ") | ||
| + | if num % 2 != 0 && num >= 0 && num <= 100 { | ||
| + | fmt.Println("true") | ||
| + | }else{ | ||
| + | fmt.Println("false") | ||
| + | } | ||
| + | |||
| + | // 13 | ||
| + | |||
| + | var x float64 | ||
| + | const RAGGIO = 1E-6 | ||
| + | fmt.Print("Inserire un numero: ") | ||
| + | fmt.Scan(&x) | ||
| + | |||
| + | fmt.Print("Il numero è vicino a 10: ") | ||
| + | if x >= (10 - RAGGIO ) && x <= ( 10 + RAGGIO ) { | ||
| + | fmt.Println("true") | ||
| + | }else{ | ||
| + | fmt.Println("false") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | /// | ||
| + | |||
| + | |||
| + | ``` | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | ==== ESERCIZIO 1a ==== | ||
| + | |||
| + | |||
| + | Scrivere un programma Go 'voto_valido.go' che legge un numero intero. | ||
| + | Se il numero non è compreso tra 0 e 30, stampa “voto non valido”, altrimenti non stampa niente. | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | ``` go | ||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main(){ | ||
| + | var a int | ||
| + | fmt.Print("Scrivere il numero ") | ||
| + | fmt.Scan(&a) | ||
| + | if (a >= 0) && (a <= 30) { | ||
| + | fmt.Println("Il voto è valido") | ||
| + | } else { | ||
| + | fmt.Println("Il voto non è valido deve essere compreso tra 0 e 30") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | import ( | ||
| + | ."fmt" | ||
| + | ) | ||
| + | |||
| + | func main() { | ||
| + | var x int | ||
| + | Println("Inserisci il voto") | ||
| + | Scan(&x) | ||
| + | if !(x >=0 && x<=30) { | ||
| + | Println("Voto non valido ") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main(){ | ||
| + | var voto int | ||
| + | fmt.Print("Inserire un voto: ") | ||
| + | fmt.Scan(&voto) | ||
| + | if(voto > 0) && (voto < 30){ | ||
| + | fmt.Println("Il voto:",voto,"è valido") | ||
| + | }else{ | ||
| + | fmt.Println("Il voto:",voto,"non è valido.") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var n int | ||
| + | fmt.Print("Inserire un numero: ") | ||
| + | fmt.Scan(&n) | ||
| + | if n > 30 { | ||
| + | fmt.Println("Voto non valido") | ||
| + | } else { | ||
| + | fmt.Println() | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | func main() { | ||
| + | var voto int | ||
| + | fmt.Print("Inserisci voto: ") | ||
| + | fmt.Scan(&voto) | ||
| + | if voto < 0 || voto > 30 { | ||
| + | fmt.Println("Voto non valido.") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | ==== ESERCIZIO 1b (MAGGIORE) ==== | ||
| + | |||
| + | |||
| + | Scrivere un programma Go maggiore.go che legge due interi e stampa il maggiore fra i due. | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var x,y int | ||
| + | fmt.Println("inserisci due numeri") | ||
| + | fmt.Scan(&x, &y) | ||
| + | if x>y { | ||
| + | fmt.Println(" il primo è maggiore del secondo") | ||
| + | } else { | ||
| + | fmt.Println("il secondo è maggiore del primo") | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | func main() { | ||
| + | var n1, n2 int | ||
| + | fmt.Print("Inserisci n_1: ") | ||
| + | fmt.Scan(&n1) | ||
| + | fmt.Print("Inserisci n_2: ") | ||
| + | fmt.Scan(&n2) | ||
| + | if n1 > n2 { | ||
| + | fmt.Println(n1) | ||
| + | } else { | ||
| + | fmt.Println(n2) | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | import "fmt" | ||
| + | |||
| + | func main(){ | ||
| + | var x, y int | ||
| + | fmt.Println("inserire il primo numero") | ||
| + | fmt.Scan(&x) | ||
| + | fmt.Println("inserire il secondo numero") | ||
| + | fmt.Scan(&y) | ||
| + | if x > y{ | ||
| + | fmt.Println(x,"è più grande di",y) | ||
| + | }else if y > x{ | ||
| + | fmt.Println(y,"è più grande di",x) | ||
| + | }else{ | ||
| + | fmt.Println("I numeri sono identici:",x,"e",y) | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main(){ | ||
| + | |||
| + | var num1, num2 float64 | ||
| + | |||
| + | fmt.Scan(&num1) | ||
| + | fmt.Scan(&num2) | ||
| + | |||
| + | if num1 > num2{ | ||
| + | fmt.Println("Il primo numero è maggiore del secondo") | ||
| + | fmt.Println(num1) | ||
| + | }else{ | ||
| + | fmt.Println("Il secondo numero è maggiore del primo:") | ||
| + | fmt.Println(num2) | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var a, b int | ||
| + | fmt.Print("Inserisci due numeri: ") | ||
| + | fmt.Scan(&a, &b) | ||
| + | if a > b { | ||
| + | fmt.Println("Il maggiore dei due è", a) | ||
| + | } else if b > a { | ||
| + | fmt.Println("Il maggiore dei due è", b) | ||
| + | } else { | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var num1,num2 int | ||
| + | fmt.Println("inserire primo numero") | ||
| + | fmt.Scan(&num1) | ||
| + | fmt.Println("inserire secondo numero") | ||
| + | fmt.Scan(&num2) | ||
| + | if num1>num2{ | ||
| + | fmt.Println(num1) | ||
| + | }else if num2>num1{ | ||
| + | fmt.Println(num2) | ||
| + | }else{ | ||
| + | fmt.Println("i numeri inseriti sono uguali") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var num1, num2 int | ||
| + | |||
| + | fmt.Print("Inserire due numeri: ") | ||
| + | fmt.Scan(&num1, &num2) | ||
| + | |||
| + | if num1 == num2 { | ||
| + | fmt.Println("I numeri sono uguali") | ||
| + | }else if num1 > num2 { | ||
| + | fmt.Println("Il numero maggiore è", num1) | ||
| + | }else { | ||
| + | fmt.Println("Il numero maggiore è", num2) | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | package main | ||
| + | import "fmt" | ||
| + | var a,b int | ||
| + | func main() { | ||
| + | fmt.Println("questo programma una volta inseriti 2 valori, identifica in maggiore", "inserisca il primo valore") | ||
| + | fmt.Scan(&a) | ||
| + | fmt.Println("inserisca il secondo valore") | ||
| + | fmt.Scan(&b) | ||
| + | if a==b{ | ||
| + | fmt.Println("i due valori sono uguali") | ||
| + | }else if a>b{ | ||
| + | fmt.Println(a) | ||
| + | }else { | ||
| + | fmt.Println(b) | ||
| + | } | ||
| + | } | ||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var n1, n2 int | ||
| + | fmt.Println("Inserisci un numero: ") | ||
| + | fmt.Scan(&n1) | ||
| + | fmt.Println("inserisci un altro numero: ") | ||
| + | fmt.Scan(&n2) | ||
| + | |||
| + | fmt.Print("Il maggiore è: ") | ||
| + | |||
| + | if n1 > n2 { | ||
| + | fmt.Println(n1) | ||
| + | } else if n1 == n2 { | ||
| + | fmt.Println("Nessuno dei due, sono uguali!") | ||
| + | } else { | ||
| + | fmt.Println(n2) | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main(){ | ||
| + | var a, b int | ||
| + | |||
| + | fmt.Print("inserisci a: ") | ||
| + | fmt.Scan(&a) | ||
| + | fmt.Print("inserisci b: ") | ||
| + | fmt.Scan(&b) | ||
| + | |||
| + | if a>b { | ||
| + | fmt.Println(a) | ||
| + | } else if b>a { | ||
| + | fmt.Println(b) | ||
| + | } else { | ||
| + | fmt.Println("i due numeri sono uguali!") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | ==== ESERCIZIO 2a (PARI-DISPARI) ==== | ||
| + | |||
| + | Scrivere un programma pari_dispari.go che legge un intero n e, a seconda del valore di n, stampa uno dei messaggi "n è pari" oppure "n è dispari". | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main(){ | ||
| + | var n int | ||
| + | |||
| + | fmt.Print("Inserire un numero\n--> ") | ||
| + | fmt.Scan(&n) | ||
| + | |||
| + | if n%2==0 { | ||
| + | fmt.Println("Il numero", n, "è pari") | ||
| + | } else { | ||
| + | fmt.Println("Il numero", n, "è dispari") | ||
| + | } | ||
| + | |||
| + | } | ||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import ( | ||
| + | "fmt" | ||
| + | ) | ||
| + | |||
| + | func main() { | ||
| + | var n int | ||
| + | fmt.Print("inserire un numero: ") | ||
| + | fmt.Scan(&n) | ||
| + | fmt.Print("il numero è ") | ||
| + | if n % 2 != 0 { | ||
| + | fmt.Println("dis") | ||
| + | } | ||
| + | fmt.Print("pari") | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var num int | ||
| + | fmt.Println("inserire numero") | ||
| + | fmt.Scan(&n) | ||
| + | if num%2==0{ | ||
| + | fmt.Println("il valore inserito è pari") | ||
| + | }else{ | ||
| + | fmt.Println("il valore inserito è dispari") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main(){ | ||
| + | |||
| + | var n int | ||
| + | fmt.Scan(&n) | ||
| + | |||
| + | if n%2==0{ | ||
| + | fmt.Println("Il numero è pari") | ||
| + | }else { | ||
| + | fmt.Println("Il numero è dispari") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var n int | ||
| + | fmt.Print("Iserire un numero: ") | ||
| + | fmt.Scan(&n) | ||
| + | if n%2==0 { | ||
| + | fmt.Println(n,"è pari") | ||
| + | } else { | ||
| + | fmt.Println(n, "è dispari") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | ==== ESERCIZIO 2b (FRAZIONI) ==== | ||
| + | |||
| + | |||
| + | Scrivere un programma frazioni.go che verifica se due frazioni num1/den1 e num2/den2 sono equivalenti e stampa "equivalenti" o "non equivalenti", a seconda del caso. Usare il tipo int per i dati in input. Pensate a una soluzione che non faccia uso di float64. | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import ( | ||
| + | "fmt" | ||
| + | ) | ||
| + | |||
| + | func main() { | ||
| + | var num1, num2, den1, den2 int | ||
| + | fmt.Println("inserire la prima frazione") | ||
| + | fmt.Scan(&num1) | ||
| + | fmt.Scan(&den1) | ||
| + | fmt.Println("inserire la seconda frazione") | ||
| + | fmt.Scan(&num2) | ||
| + | fmt.Scan(&den2) | ||
| + | if num1 * den2 == num2 * den1 { | ||
| + | fmt.Println("le due frazioni", num1, "/", den1, "e", num2, "/", den2, "sono equivalenti") | ||
| + | } else { | ||
| + | fmt.Println("le due frazioni", num1, "/", den1, "e", num2, "/", den2, "non sono equivalenti") | ||
| + | } | ||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var num1, num2, num3, num4 int | ||
| + | fmt.Print("frazione 1:") | ||
| + | fmt.Scan(&num1, &num2) | ||
| + | fmt.Print("frazione 2:") | ||
| + | fmt.Scan(&num3, &num4) | ||
| + | if num1*num4==num2*num3{ | ||
| + | fmt.Println("equivalenti") | ||
| + | }else { | ||
| + | fmt.Println("non equivalenti") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | ==== ESERCIZIO 2b (FRAZIONI) ==== | ||
| + | |||
| + | Scrivere un programma frazioni.go che verifica se due frazioni num1/den1 e num2/den2 sono equivalenti e stampa "equivalenti" o "non equivalenti", a seconda del caso. Usare il tipo int per i dati in input. Pensate a una soluzione che non faccia uso di float64.*/ | ||
| + | |||
| + | package main | ||
| + | import "fmt" | ||
| + | |||
| + | func main(){ | ||
| + | var num1, num2, den1, den2 int | ||
| + | fmt.Print("Inserire la prima frazione (numeratore/denominatore): ") | ||
| + | fmt.Scan(&num1) | ||
| + | fmt.Scan(&den1) | ||
| + | fmt.Print("Inserire la seconda frazione (numeratore/denominatore): ") | ||
| + | fmt.Scan(&num2) | ||
| + | fmt.Scan(&den2) | ||
| + | if(num1/den1 == num2/den2){ | ||
| + | fmt.Println("Le equazioni sono equivalenti") | ||
| + | }else{ | ||
| + | fmt.Println("Le equazioni sono diverse") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | ==== ESERCIZIO 2b (FRAZIONI) ==== | ||
| + | |||
| + | Scrivere un programma frazioni.go che verifica se due frazioni num1/den1 e num2/den2 sono equivalenti e stampa "equivalenti" o "non equivalenti", a seconda del caso. Usare il tipo int per i dati in input. Pensate a una soluzione che non faccia uso di float64.*/ | ||
| + | |||
| + | package main | ||
| + | import "fmt" | ||
| + | |||
| + | func main(){ | ||
| + | var num1, num2, den1, den2 int | ||
| + | fmt.Print("Inserire la prima frazione (numeratore/denominatore): ") | ||
| + | fmt.Scan(&num1) | ||
| + | fmt.Scan(&den1) | ||
| + | fmt.Print("Inserire la seconda frazione (numeratore/denominatore): ") | ||
| + | fmt.Scan(&num2) | ||
| + | fmt.Scan(&den2) | ||
| + | if(num1/den1 == num2/den2){ | ||
| + | fmt.Println("Le equazioni sono equivalenti") | ||
| + | }else{ | ||
| + | fmt.Println("Le equazioni sono diverse") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main(){ | ||
| + | var num1, num2, den1, den2 int | ||
| + | |||
| + | fmt.Print("inserisci la prima frazione: ") | ||
| + | fmt.Scan(&num1) | ||
| + | fmt.Scan(&den1) | ||
| + | |||
| + | fmt.Print("inserisci la seconda frazione: ") | ||
| + | fmt.Scan(&num2) | ||
| + | fmt.Scan(&den2) | ||
| + | |||
| + | if (num1/den1 == num2/den2){ | ||
| + | fmt.Println("equivalenti") | ||
| + | } else { | ||
| + | fmt.Println("non equivalenti") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | //Cestone - 2b | ||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var num1,num2,den1,den2 int | ||
| + | fmt.Print("inserire la prima frazione(tipo 1/2): ") | ||
| + | fmt.Scan(&num1) | ||
| + | fmt.Scan(&den1) | ||
| + | fmt.Print("inserire la seconda frazione(tipo 1/2): ") | ||
| + | fmt.Scan(&num2) | ||
| + | fmt.Scan(&den2) | ||
| + | if num1*den2 == den1*num2 { | ||
| + | fmt.Println("equivalenti") | ||
| + | } else { | ||
| + | fmt.Println("non equivalenti") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | ==== ESERCIZIO 3a (INDOVINA 10) ==== | ||
| + | |||
| + | Scrivere un programma indovina_10.go che fissa un numero intero tra 1 e 10 da indovinare, legge un intero da standard input e | ||
| + | - se il numero in input è fuori dall’intervallo 1-10, stampa “Valore non valido”; | ||
| + | - se il numero è quello fissato, stampa “Hai indovinato!”; | ||
| + | |||
| + | |||
| + | |||
| + | - altrimenti stampa “Non hai indovinato”. | ||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main(){ | ||
| + | var tentativo, n int | ||
| + | |||
| + | n = 5 | ||
| + | fmt.Print("inserisci il tuo tentativo (1->10): ") | ||
| + | fmt.Scan(&tentativo) | ||
| + | |||
| + | if tentativo == n { | ||
| + | fmt.Println("Hai indovinato!") | ||
| + | } else if tentativo<1 || tentativo>10 { | ||
| + | fmt.Println("Valore non valido!") | ||
| + | } else { | ||
| + | fmt.Println("Non hai indovinato!") | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var n int | ||
| + | fmt.Println("a che numero ha pensato il computer secondo te?") | ||
| + | for { | ||
| + | fmt.Scan(&n) | ||
| + | if n == 6 { | ||
| + | |||
| + | fmt.Println("hai indovinato!! avevo pensato proprio a 6") | ||
| + | break | ||
| + | } else { | ||
| + | fmt.Println("non hai indovinato!! riprova:") | ||
| + | } | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import ( | ||
| + | ."fmt" | ||
| + | ) | ||
| + | |||
| + | func main() { | ||
| + | y:=5 | ||
| + | var x int | ||
| + | for { | ||
| + | Println("Inserisci un numero") | ||
| + | Scan(&x) | ||
| + | if x<1 || x>10 { | ||
| + | Println("Input non valido") | ||
| + | continue | ||
| + | } else if x==y { | ||
| + | Println("Hai indovinato") | ||
| + | break | ||
| + | } else { | ||
| + | Println("Non hai indovinato ") | ||
| + | } | ||
| + | } | ||
| + | } | ||
| + | |||
| + | ==== ESERCIZIO 3c (TARIFFE SCONTATE) ==== | ||
| + | |||
| + | |||
| + | Scrivere un programma tariffe.go che chiede età (int) e se studente (bool) e stampa il costo del biglietto di ingresso secondo la seguente tabella:[0 - 9) anni: gratis[9 - 18) anni: 5[18 - 26) anni: 7.5[26 - 65) anni: 10>= 65 anni: 7.5studenti >= 18: 5*/ | ||
| + | |||
| + | //Bertalero: tariffe.go | ||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var eta int | ||
| + | var studente bool | ||
| + | fmt.Print("inserire età:") | ||
| + | fmt.Scan(&eta) | ||
| + | fmt.Print("la persona è uno studente ('1' oppure 'true' se studente, '0' oppure 'false' altrimenti)?") | ||
| + | fmt.Scan(&studente) | ||
| + | if studente==false { | ||
| + | if eta>=0&&eta<9{ | ||
| + | fmt.Println("gratis") | ||
| + | } else if eta>=9&&eta<18{ | ||
| + | fmt.Println("5") | ||
| + | }else if (eta>=18&&eta<26) || (eta>=65){ | ||
| + | fmt.Println("7.5") | ||
| + | }else if eta>=26&&eta<65{ | ||
| + | fmt.Println("10") | ||
| + | }else{ | ||
| + | fmt.Println("Età non valida") | ||
| + | } | ||
| + | }else { | ||
| + | if eta>=18{ | ||
| + | fmt.Println("5") | ||
| + | }else if eta>=0&&eta<18{ | ||
| + | fmt.Println("gratis") | ||
| + | }else{ | ||
| + | fmt.Println("Età non valida") | ||
| + | } | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | //cestone - esercizio3c | ||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var eta int | ||
| + | var studente bool | ||
| + | fmt.Print("inserisci età: ") | ||
| + | fmt.Scan(&eta) | ||
| + | fmt.Print("(1=si,0=no)Sei uno studente?") | ||
| + | fmt.Scan(&studente) | ||
| + | if studente && eta>=18{ | ||
| + | fmt.Print("prezzo 5 euro") | ||
| + | } else { | ||
| + | if eta < 9 { | ||
| + | fmt.Println("gratis") | ||
| + | } else if eta < 18 { | ||
| + | fmt.Println("prezzo 5 euro") | ||
| + | } else if eta < 26 { | ||
| + | fmt.Println("prezzo 7.5 euro") | ||
| + | } else if eta < 65 { | ||
| + | fmt.Println("prezzo 10 euro") | ||
| + | } else { | ||
| + | fmt.Println("prezzo 7.5 euro") | ||
| + | } | ||
| + | } | ||
| + | } | ||
| + | |||
| + | |||
| + | package main | ||
| + | |||
| + | import "fmt" | ||
| + | |||
| + | func main() { | ||
| + | var eta int | ||
| + | var studente bool | ||
| + | |||
| + | fmt.Print("Inserire l'età: ") | ||
| + | fmt.Scan(&eta) | ||
| + | fmt.Print("Sei uno studente? ( sì = true - no = false): ") | ||
| + | fmt.Scan(&studente) | ||
| + | |||
| + | if eta >= 0 && eta < 9 { | ||
| + | fmt.Println("Il biglietto è gratis") | ||
| + | }else if studente || eta >= 9 && eta < 18 { | ||
| + | fmt.Println("Il biglietto costa 5 euro") | ||
| + | }else if eta >= 18 && eta < 26 || eta > 65 { | ||
| + | fmt.Println("Il biglietto costa 7,50 euro") | ||
| + | }else{ | ||
| + | fmt.Println("Il biglietto costa 10 euro") | ||
| + | } | ||
| + | } | ||
