soluzioni lab04

Lab04/_soluzioni/cesare.go

+//cesare.go
+
+/*
+Scrivere un programma cesare.go che legge da standard input
+un valore intero non negativo k (la chiave di cifratura) e
+una sequenza di lettere minuscole consecutive
+(sulla stessa riga e senza spazi) terminate da <invio> ('\n').
+Il programma stampa la sequenza letta cifrata secondo il
+cifrario di Cesare, usando come chiave k (quella fornita dall'utente):
+ogni lettera del testo in chiaro è sostituita nel
+testo cifrato dalla lettera che si trova k posizioni dopo
+nell'alfabeto, ritornando dopo la zeta alla lettera a.
+
+
+Esempi
+-------
+chiave: 2
+caratteri da cifrare:
+zaprb
+bcrtd
+è il testo cifrato
+
+chiave: 100
+caratteri da cifrare:
+abcd
+wxyz
+è il testo cifrato
+*/
+
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	var char, cifrato rune
+	var chiave int
+
+	fmt.Print("chiave: ")
+	fmt.Scan(&chiave)
+
+	fmt.Println("caratteri da cifrare: ")
+
+	for {
+		fmt.Scanf("%c", &char)
+		if char == '\n' {
+			break
+		}
+		cifrato = rune((int(char-'a')+chiave)%26 + 'a')
+		fmt.Print(string(cifrato))
+	}
+	fmt.Println("\nè il testo cifrato")
+}

Lab04/_soluzioni/crescente.go

+/*
+legge da standard input una stringa di sole lettere minuscole e la stampa inserendo un '-' ogni volta che una lettera viene prima in ordine alfabetico della lettera precedente.
+*/
+
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	var s string
+	fmt.Scan(&s)
+
+	l := len(s)
+	fmt.Print(string(s[0]))
+	for i := 1; i < l; i++ {
+		if s[i] < s[i-1] {
+			fmt.Print("-")
+		}
+		fmt.Print(string(s[i]))
+	}
+	fmt.Println()
+}

Lab04/_soluzioni/disegna_slash.go

+/*
+Slash
+-----
+
+Scrivere un programma disegna_slash.go che legge un intero
+positivo n e stampa uno slash (\)  di asterischi di altezza n.
+
+Esempio
+-------
+
+dimensione \ ?: 3
+*
+ *
+  *
+
+*/
+
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	var n int
+	fmt.Print("dimensione \\ ? ")
+	fmt.Scan(&n)
+
+	for i := 0; i < n; i++ {
+		for j := 0; j < i; j++ {
+			fmt.Print(string(' '))
+		}
+		fmt.Println(string('*'))
+	}
+}

Lab04/_soluzioni/disegna_v.go

+/*
+Lettera V
+---------
+
+Scrivere un programma disegna_v.go che legge un intero
+positivo n e stampa una v  di asterischi di altezza n.
+
+Esempio
+-------
+
+dimensione v? 3
+*   *
+ * *
+  *
+
+*/
+
+package main
+
+import "fmt"
+
+func main() {
+	var n int
+	fmt.Print("dimensione v? ")
+	fmt.Scan(&n)
+
+	// i due lati della V
+	for i := 0; i < n-1; i++ {
+		for j := 0; j < i; j++ {
+			fmt.Print(string(' '))
+		}
+		fmt.Print(string('*'))
+		for j := 0; j < 2*(n-i-2)+1; j++ {
+			fmt.Print(string(' '))
+		}
+		fmt.Println(string('*'))
+	}
+	// punta della V
+	for j := 0; j < n-1; j++ {
+		fmt.Print(string(' '))
+	}
+	fmt.Println(string('*'))
+}

Lab04/_soluzioni/es0.go

+//es0.go
+
+/*
+Scrivere un programma es0.go che legge un byte e
+- lo stampa (occorre una fmt.Scanf in più per catturare l'invio)
+- stampa precedente, byte stesso, e successivo in ordine
+lessicografico (ASCII). Ad es. per 'd': cde
+- stabilisce se è una lettera tra A e L, o altro (stampa "A-L" o "altro")
+poi legge una stringa (di rune) e la stampa in verticale. Ad esempio città:
+c
+i
+t
+t
+à
+*/
+
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	var char byte
+
+	fmt.Print("un carattere: ")
+	fmt.Scanf("%c", &char)
+
+	fmt.Println(string(char))
+	fmt.Printf("%c %c %c\n", char-1, char, char+1)
+
+	if char >= 'A' && char <= 'L' {
+		fmt.Println("A-L")
+	} else {
+		fmt.Println("altro")
+	}
+
+	var str string
+	fmt.Print("una parola: ")
+	fmt.Scan(&str)
+	for _, c := range str {
+		fmt.Println(string(c))
+	}
+}

Lab04/_soluzioni/fibonacci.go

+/*
+fibonacci fino a n-esimo
+*/
+
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	var n int
+	fmt.Print("un numero: ")
+	fmt.Scan(&n)
+
+	fib1 := 0
+	fib2 := 1
+	for i := 1; i <= n; i++ {
+		fib1, fib2 = fib2, fib1+fib2
+		for j := 1; j <= fib1; j++ {
+			fmt.Print("*")
+		}
+		fmt.Println()
+	}
+}

Lab04/_soluzioni/lunghezza_tot.go

+//lunghezza_tot.go
+/*
+legge da standard input un int totLen e una sequenza di stringhe (una per riga) sommandone le lunghezze fino a raggiungere (o superare) totLen.
+Raggiunto totLen, il programma stampa la somma delle lunghezze e la concatenazione delle stringhe lette.
+*/
+
+package main
+
+import "fmt"
+
+func main() {
+	var (
+		stringa string
+		totLen  int
+	)
+	fmt.Print("lunghezza totale: ")
+	fmt.Scan(&totLen)
+
+	somma := 0
+	for somma < totLen {
+		fmt.Scan(&stringa)
+		somma += len(stringa)
+	}
+
+	fmt.Println(somma)
+}

Lab04/_soluzioni/maxGradino.go

+/*Definiamo "gradino" una sequenza di (uno o più) interi non negativi uguali seguita
+da un'altra sequenza di (uno o più) interi più grandi di 1 (es. 1 1 2 2 2).
+Scrivere un programma gradino.go che, data in input una sequenza di interi
+tali che ogni intero è >= del precedente, stampa la lunghezza (il numero di interi)
+del gradino più lungo. (Si noti che i gradini si sovrappongono).
+Il programma termina quando legge un numero minore di quello appena letto.
+Per input 2 2 3 3 4 4 4 5 6 6 6 7, l'output è 5 (il gradino 3 3 4 4 4).
+*/
+
+package main
+
+import "fmt"
+
+func main() {
+	var oldNum, newNum int
+
+	maxStep := 0
+	prevLen := 0
+	currLen := 1
+	fmt.Scan(&newNum)
+	for newNum >= oldNum {
+		oldNum = newNum
+		fmt.Scan(&newNum)
+
+		if newNum == oldNum {
+			currLen++
+		} else {
+			currStep := prevLen + currLen
+			if maxStep < currStep {
+				maxStep = currStep
+			}
+			prevLen = currLen
+			currLen = 1
+		}
+	}
+	fmt.Println(maxStep)
+}

Lab04/_soluzioni/max_char.go

+//max_char.go
+/*
+legge da standard input una sequenza di 5 caratteri ASCII (byte) e stampa il maggiore in ordine lessicografico (cioè con il codice ASCII più alto).
+*/
+
+package main
+
+import "fmt"
+
+func main() {
+	var char, max byte
+	max = 0
+	for i := 0; i < 5; i++ {
+		fmt.Scanf("%c", &char)
+		if char > max {
+			max = char
+		}
+	}
+	fmt.Println(string(max))
+	fmt.Scanf("%c", &char) //per intercettare l'invio
+}

Lab04/_soluzioni/max_num_cifre_pari.go

+//Massimo numero di cifre pari in una serie di stringhe
+
+package main
+
+import (
+	"fmt"
+	"io"
+)
+
+func main() {
+	var numero string
+
+	max := 0
+	for {
+		_, err := fmt.Scan(&numero)
+		if err == io.EOF {
+			break
+		}
+		count := 0
+		for _, cifra := range numero {
+			if (cifra-'0')%2 == 0 {
+				count++
+			}
+		}
+		if count > max {
+			max = count
+		}
+	}
+	fmt.Println(max)
+}

Lab04/_soluzioni/max_somma_cifre.go

+/*
+Si vuole scrivere un programma max_somma_cifre.go che legge da standard input una serie di numeri >= 0, terminata da 999, trova il numero (escludendo 999)
+la cui somma delle cifre è la maggiore e stampa tale somma.
+
+Scrivi il programma max_somma_cifre.go completando il seguente codice.
+
+Nota che il for che calcola la somma delle cifre è annidato nel for che scorre la sequenza di numeri.
+*/
+
+package main
+
+import "fmt"
+
+func main() {
+	var n int
+
+	maxSum := 0
+	for n != 999 {
+		sumOfDigits := 0
+		for n > 0 {
+			digit := n % 10
+			n /= 10
+			sumOfDigits += digit
+		}
+		if sumOfDigits > maxSum {
+			maxSum = sumOfDigits
+		}
+		fmt.Scan(&n)
+	}
+	fmt.Println(maxSum)
+}

Lab04/_soluzioni/minu_maiu.go

+package main
+
+import (
+	"fmt"
+	"unicode"
+)
+
+func main() {
+	var (
+		parola     string
+		minu, maiu bool
+	)
+
+	fmt.Scan(&parola)
+	for _, c := range parola {
+		if unicode.IsLower(c) {
+			minu = true
+		} else if unicode.IsUpper(c) {
+			maiu = true
+		}
+		if maiu && minu {
+			break
+		}
+	}
+	fmt.Println("minu:", minu, "maiu:", maiu)
+}

Lab04/_soluzioni/num_max.go

+//num_max.go
+
+package main
+
+import "fmt"
+
+func main() {
+	var n int
+
+	fmt.Scan(&n)
+	max := n
+	count := 1
+	for i := 1; i < 10; i++ {
+		fmt.Scan(&n)
+		if n == max {
+			count++
+		} else if n > max {
+			max = n
+			count = 1
+		}
+	}
+	fmt.Println(max, count)
+}

Lab04/_soluzioni/num_sequenze.go

+/*
+Scrivere un programma num_sequenze.go che legge da standard input una sequenza di uni (1) e zeri (0) (terminata da un 2),
+che inizia e finisce con 1, e stampa il numero di sottosequenze di zeri.
+Ad esempio per input 1 1 0 0 1 0 1 0 0 0 1 1 1 0 1,
+l'output è 4.
+(si considerano valide anche le sottosequenze di lunghezza 1)
+*/
+
+package main
+
+import "fmt"
+
+func main() {
+	var currentBit, previousBit int
+
+	// in questo problema non è necessario, come spesso capita, fare una prima lettura prima del for per inizializzare adeguatamente previous: alla prima iterazione previous sarà zero, senza nessun effetto sul risultato
+	count := 0
+	for {
+		fmt.Scan(&currentBit)
+		if currentBit == 2 {
+			break
+		}
+		// per identificare e contare le sottosequenze di zeri basta intercettare e contare tutte e sole le volte in cui c'è un 1 seguito da uno 0
+		if previousBit == 1 && currentBit == 0 {
+			count++
+		}
+		previousBit = currentBit
+
+	}
+	fmt.Println(count)
+}

Lab04/_soluzioni/pos_alfabeto.go

+package main
+
+import "fmt"
+
+func main() {
+	var char byte
+	fmt.Print("una sequenza di caratteri terminata da '.': ")
+	somma := 0
+	for {
+		fmt.Scanf("%c", &char)
+		if char == '.' {
+			break
+		}
+		fmt.Print(string(char))
+		if 'a' <= char && char <= 'z' {
+			fmt.Print(" è la ", char-'a'+1, "^a\n")
+		} else if '0' <= char && char <= '9' {
+			n := int(char - '0')
+			fmt.Print(" - ", n, "\n")
+			somma += n
+		} else {
+			fmt.Println(" - altro")
+
+		}
+	}
+	fmt.Scanf("%c", &char)
+	fmt.Println("somma:", somma)
+
+	fmt.Println("bye")
+}

Lab04/_soluzioni/trova.go

+//trova.go
+/*
+legge da standard input un carattere (runa) e una stringa e stampa la posizione del carattere nella stringa (la prima volta che appare), o -1 se il carattere non c'è.
+*/
+
+package main
+
+import "fmt"
+
+func main() {
+	var (
+		char   rune
+		parola string
+	)
+	fmt.Print("un carattere: ")
+	fmt.Scanf("%c", &char)
+	fmt.Print("una parola: ")
+	fmt.Scan(&parola)
+
+	pos := -1
+	for i, c := range parola {
+		if c == char {
+			pos = i
+			break
+		}
+	}
+	fmt.Println(pos)
+}

Lab04/_soluzioni/ultima_pioggia.go

+//Last rainy day
+
+package main
+
+import "fmt"
+
+func main() {
+	var mmRain int
+
+	lastRainyDay := -1
+	for i := 1; i <= 10; i++ {
+		fmt.Scan(&mmRain)
+		if mmRain > 0 {
+			lastRainyDay = i
+		}
+	}
+	fmt.Println(lastRainyDay)
+}
+
+//nelle specifiche non era stato previsto il caso che non piovesse mai.
+//Nel caso invece dell'ultima print ci va un if-else:
+/*
+    if lastRainyDay == -1 {
+		fmt.Println("non ha mai piovuto")
+	} else {
+			fmt.Println(lastRainyDay)
+	}
+*/