Università Statale di Milano - Dipartimento di Informatica: 3a lezione sul Linguaggio GO (Golang)

I cicli (Iterazione) e le stringhe con il linguaggio Golang



ESERCIZIO 1
Creare un programma che legga un intero n inserito da tastiera e quindi disegna un quadrato di n asterischi intervallati da spazi.


/*
Dato un numero n letto a tastiera,
stampa un quadrato n x n di * intervallati da spazi
*/
package main

import "fmt"

func main() {

var lato int

fmt.Print("Inserisci un numero: ")
fmt.Scan(&lato)

for i := 0; i < lato; i++ {
for j := 0; j < lato-1; j++ {
fmt.Print("* ")
}
fmt.Println("*") // l'ultimo asterisco non deve
// essere seguito da spazio ma
// da un carattere di fine linea
}

}

ESERCIZIO 2
Scrivete un programma che, letto un numero intero n, produca in output una “figura” di n righe costituite ciascuna da n simboli intervallati da spazi, alternando fra loro righe costituite solo da simboli * (asterisco) intervallati da spazi e righe costituite solo da simboli + (più) intervallati da spazi.

SUGGERIMENTO
Utilizzate due cicli for nidificati e stampate i simboli + e * (intervallati da spazi) nella posizione corretta. Verificate il fatto che la posizione sia corretta o meno in base al valore della variabile di indice del ciclo più esterno.
Assumendo che:
- le righe della figura siano numerate a partire da 0 (dall’alto verso il basso);
- le righe della figura siano identificate/associate dai/ai valori della variabile di indice del ciclo più esterno;
nel ciclo di seguito riportato il blocco di codice (1) viene eseguito per le righe pari, mentre il blocco di codice (2) viene eseguito per le righe dispari.

/*
Dato un numero n letto a tastiera,
stampa un quadrato n x n di righe alternate:
1 formata da asterischi,
1 formata da più
*/
package main

import "fmt"

func main() {

var lato int
car := ""
fmt.Print("Inserisci il lato del quadrato: ")
fmt.Scan(&lato)

for i := 0; i < lato; i++ {
if (i % 2) == 0 {
car = "*"
} else {
car = "+"
}
for j := 0; j < lato-1; j++ {
fmt.Print(car + " ")
}
fmt.Println(car) // l'ultimo carattere non deve
// essere seguito da spazio ma
// da un carattere di fine linea
}

}

ESERCIZIO 3
Scrivere un programma che, letto da standard input un numero intero n, produca in output una “figura” di n righe costituite ciascuna da n simboli intervallati da spazi, alternando fra loro: (1) righe costituite solo da simboli * (asterisco) intervallati da spazi, (2) righe costituite solo da simboli + (più) intervallati da spazi, e (3) righe costituite solo da simboli o (lettera o) intervallati da spazi


/*
Dato un numero n letto a tastiera,
stampa un quadrato n x n di righe alternate:
1 formata da asterischi,
1 formata da più
*/
package main

import "fmt"

func main() {

var lato int
car := ""
fmt.Print("Inserisci il lato del quadrato: ")
fmt.Scan(&lato)

for i := 0; i < lato; i++ {
if (i % 3) == 0 {
car = "*"
} else if (i % 3) == 1 {
car = "+"
} else {
car = "O"
}
for j := 0; j < lato-1; j++ {
fmt.Print(car + " ")
}
fmt.Println(car) // l'ultimo carattere non deve
// essere seguito da spazio ma
// da un carattere di fine linea
}

}

ESERCIZIO 4
Creare un programma che disegni il quadrato di asterischi ( con l’interno riempito di + (i simboli sono anche in questo caso separati da spazi). Ovvero il programma dovrebbe funzionare come segue:

SUGGERIMENTO
Utilizzate due cicli for nidificati e stampate i simboli + e * (intervallati da spazi) nella posizione corretta. Verificate il fatto che la posizione sia corretta o meno in base al valore delle variabili di indice. Questa volta, per determinare se la posizione è corretta o meno, devono essere considerati i valori di entrambe le variabili di indice.

/*
Dato un numero n letto a tastiera,
stampa un quadrato n x n di * .
L'interno del quadrato è composto da caratteri '+'
*/
package main

import "fmt"

func main() {

var lato, j int

fmt.Print("Inserisci un numero: ")
fmt.Scan(&lato)
primaUltima := ""
for j = 0; j < lato-1; j++ {
primaUltima = primaUltima + "* "
}
primaUltima = primaUltima + "*"

interna := "* "
for j = 1; j < lato-1; j++ {
interna = interna + "+ "
}
interna = interna + "*"

fmt.Println(primaUltima)
for j = 1; j < lato-1; j++ {
fmt.Println(interna)
}

fmt.Println(primaUltima)
}

ESERCIZIO 5 FIGURE

Scrivete altri due programmi simili a quelli degli esercizi precedenti.
Tutti e 3 i programmi prendono in input un intero n e producono in output una figura di n righe e n colonne, costituita da simboli * (asterisco) e + (più) non intervallati da spazi. La differenza fra un programma e l’altro è il modo in cui sono alternati i simboli, come indicato negli esempi che seguono.

Primo programma:
Ognuna delle n righe è composta da simboli * e + alternati.

/*
Dato un numero n letto a tastiera,
stampa un quadrato n x n di righe alternate:
1 formata da asterischi,
1 formata da più
*/
package main

import "fmt"

func main() {

var lato int
fmt.Print("Inserisci il lato del quadrato: ")
fmt.Scan(&lato)

for i := 0; i < lato; i++ {
for j := 0; j < lato-1; j++ {
if (j % 2) == 0 {
fmt.Print("* ")
} else {
fmt.Print("+ ")
}
}
if ((lato - 1) % 2) == 0 {
fmt.Println("* ")
} else {
fmt.Println("+ ")
}
}
}


Secondo programma:

Ognuna delle n righe è composta da coppie di simboli * e + (ovvero da ** e ++) alternati, fino a raggiungere gli n simboli. Attenzione che, se n è dispari, la riga sarà terminata da un solo simbolo * (asterisco) o + (più).

/*
Dato un numero n letto a tastiera,
stampa un quadrato n x n di righe alternate:
1 formata da asterischi,
1 formata da più
*/
package main

import "fmt"

func main() {

var lato int
fmt.Print("Inserisci il lato del quadrato: ")
fmt.Scan(&lato)
riga := ""
for i := 0; i < lato+2; i++ {
if i%4 <= 1 {
riga = riga + "*"
} else {
riga = riga + "+"
}
}

for i := 0; i < lato; i++ {
if (i % 2) == 0 {
fmt.Println(riga[:lato])
} else {
fmt.Println(riga[2:])
}
}
}


Terzo programma:

Il quadrato di lato n è composto da due triangoli rettangoli isosceli i cui lati sono lunghi n-1. In sostanza in questa figura, i simboli sopra la diagonale del quadrato sono +, quelli sotto sono *, mentre sulla diagonale ci sono o.

/*
Dato un numero n letto a tastiera,
stampa un quadrato n x n di righe alternate:
1 formata da asterishi,
1 formata da più
*/
package main

import "fmt"

func main() {

var lato int
fmt.Print("Inserisci il lato del quadrato: ")
fmt.Scan(&lato)
for i := 0; i < lato; i++ {
for j := 0; j < lato-1; j++ {
if i == j {
fmt.Print("O")
} else if i < j {
fmt.Print("+ ")
} else {
fmt.Print("* ")
}
}
if i == (lato - 1) {
fmt.Println("O")
} else if i < (lato - 1) {
fmt.Println("+")
} else {
fmt.Println("*")
}
}
}



ESERCIZIO 6

Disegnare un rombo

package main
import "fmt"
func main() {
    var i int
    var n int
    var m int
    var k int

    n= 1

 fmt.Print("Inserisci il numero che costituira' il raggio...  ");
    fmt.Scan(&n)
   for m=0; m<2 ; m++ {
            for i=1; i<=n ; i++ {
                     if m==0 {
                     for k=1; k<=n-i; k++ {
                         fmt.Print(" ")
                         }
                         for k=1; k<2*i; k++ {
                            fmt.Print("*")
                            }
                         }
                         if m==1{
                                   for k=1;k<=i; k++ {
                                   fmt.Print(" ")
                                   }
                                   for k=1; k<(n-i)*2; k++ {
                                            fmt.Print("*")
                                            }
                                            }
                                            fmt.Print("\n")
                         }
                         }
        
                         }

ESERCIZIO N. 7

Scrivere un programma che chieda all’utente di inserire un intero n e ne stampa quindi la conversione binaria.

package main

import (
"fmt"
)

func main() {

var n, num int    // valore decimale
strBin := "" // salvo in una stringa la conversione ottenuta

fmt.Print("Inserisci il valore da convertire: ")
fmt.Scan(&num)
n = num
for n > 0 {
bin := n % 2
n = n / 2
if bin == 0 {
strBin = "0" + strBin
} else {
strBin = "1" + strBin
}
}

fmt.Println("La rappresentazione binaria di ", num, " e' ", strBin)
}

ESERCIZIO 8 parole Palindrome
Scrivere un programma che legge una serie di parole inserite dall’utente (una parola per riga); per ogni parola letta, il programma notifica all’utente se essa è palindroma (le parole palindrome sono quelle che lette in un verso o nell'altro presentano la stessa sequenza di lettere).
Il programma non è “case sensitive” e trasforma ogni lettera maiuscola in lettera minuscola (per trasformare una stringa con caratteri maiuscoli in una con caratteri minuscoli, usate la funzione ToLower(…) del package strings); altrimenti detto, non fa distinzione tra lettere maiuscole e lettere minuscole (ad es.: la parola INGegni è considerata palindroma, mamma non lo è, acca lo è, SmS lo è).
CONSIGLIO: per eseguire test sul programma, utilizzare la redirezione di input da file.

Creare un file di testo con il nome parole.txt contenente n parole ad esempio:
ciccio
acca
Mamma
INgegni
pioip
SMS
melem
pluto
mare
sos

questo file deve esserre salvato nela cartella bin insieme al programma che chiameremo: palindrome.go.

/* Programma non CASE SENSITIVE che legge una serie di parole e
di ognuna dice se è palindroma o no*/
package main

import (
"bufio"
"fmt"
"os"
"strings"
)

func main() {
sc := bufio.NewScanner(os.Stdin)
for sc.Scan() {
text := strings.ToLower(sc.Text())
flag := true
for i := 0; i < len(text)/2; i++ {
if text[i] != text[len(text)-i-1] {
flag = false
break
}
}
if flag {
fmt.Print(text, " -> palindroma\n")
} else {
fmt.Print(text, " -> non palindroma\n")
}
}
}

per eseguire il programma e leggere i dati dal file scrivere su CMD le seguenti istruzioni:

go run palindrome.go < parole.txt

Commenti