Cicli

Scrivere un programma interattivo che chiede all’utente di inserire un numero intero e poi disegna un omino stilizzato di dimensione variabile:

Per dimensione pari a 1 viene stampato un omino con il busto composto da una sola pipe ('|'):

Insert size: 1
\o/
 |
/ \

Se l’utente inserisce 2:

Insert size: 2
\o/
 |
 |
/ \

Per 3:

Insert size: 3
\o/
 |
 |
 |
/ \

Per qualsiasi altro valore intero, il busto sarà composto a 4 segmenti:

Insert size: 100
\o/
 |
 |
 |
 |
/ \

Se il valore inserito non è intero, il programma stampa un messaggio di errore e ripete la richiesta:

Insert size: big
Invalid value "big"
Insert size: small
Invalid value "small"
Insert size: ciao miao bau
Invalid value "ciao miao bau"
Insert size: -1
\o/
 |
 |
 |
 |
/ \

Scrivi il programma Unvowelator che riceve degli argomenti da linea di comando e poi li stampa privandoli delle vocali.

Ad esempio per gli argomenti "In una tiepida notte estiva." il programma stampa:

n n tpd ntt stv.

Scrivere un programma interattivo che chiede all’utente di inserire un numero intero e poi disegna un gruppo di omini stilizzati nella quantità richiesta:

Per dimensione pari a 1 viene stampato un omino:

Insert group size: 1
\o/
 |
/ \

Se l’utente inserisce 2 vengono stampati 2 omini:

Insert group size: 2
\o/ \o/ 
 |   |  
/ \ / \ 

Per 3:

Insert group size: 3
\o/ \o/ \o/ 
 |   |   |  
/ \ / \ / \

E via dicendo. Se il valore inserito non è intero, il programma stampa un messaggio di errore e ripete la richiesta:

Insert group size: many
Invalid value "many"
Insert group size: too many
Invalid value "too many"
Insert group size: 10
\o/ \o/ \o/ \o/ \o/ \o/ \o/ \o/ \o/ \o/ 
 |   |   |   |   |   |   |   |   |   |  
/ \ / \ / \ / \ / \ / \ / \ / \ / \ / \ 

Scrivi il programma HelloPeople che riceve N nomi come argomenti da linea di comando e poi stampa altrettanti omini stilizzati. Sotto ogni omino compare il relativo nome.

Ad esempio per "Luigi Michele" il programma stampa due omini:

\o/     \o/     
 |       |      
/ \     / \     
Luigi   Michele

Invece per "Simone Luigi Pincopallino Michele Joe":

\o/          \o/          \o/          \o/          \o/          
 |            |            |            |            |           
/ \          / \          / \          / \          / \          
Simone       Luigi        Pincopallino Michele      Joe

Se non vengono forniti argomenti, il programma termina senza stampare niente.

Scrivi il programma SimpleInterest utile per calcolare l’interesse semplice di un prestito. Il programma deve funzionare nel modo seguente:

1. Chiede di inserire il capitale iniziale ($C=M_0$)

2. Se il valore inserito non è un numero valido stampa il messaggio:

    Valore C non valido "<valore>"   e ricomincia dal punto 1.
   

3. Se il valore inserito è inferiore o uguale 0 stampa:

    C deve essere maggiore di 0   e ricomincia dal punto 1.
   

4. Chiede di inserire il tasso di interesse ($i$)

5. Se il valore inserito non è un numero stampa:

    Valore i non valido "<valore>"   e ricomincia dal punto 4.
   

6. Chiede di inserire il periodo ($n$)

7. Se il valore inserito non è un numero intero stampa:

    Valore n non valido "<valore>"   e ricomincia dal punto 6.
   

8. Se il valore inserito è inferiore a 0 stampa:

    Il periodo deve deve essere positivo  e ricomincia dal punto 6.
   

9. Stampa il montante ($M_n$) del prestito

Esempio 1:

Inserire il capitale iniziale (C): 1000
Inserire il tasso di interesse (i): 5
Inserire il periodo (n): 2
M2 = 1100.0

Esempio 2:

Inserire il capitale iniziale (C): -1
Il capitale deve essere maggiore di 0
Inserire il capitale iniziale (C): bau
Valore C non valido "bau"
Inserire il capitale iniziale (C): 1000
Inserire il tasso di interesse (i): miao
Valore i non valido "miao"
Inserire il tasso di interesse (i): 7
Inserire il periodo (n): -1
Il periodo deve essere positivo
Inserire il periodo (n): cucu
Valore n non valido "cucu"
Inserire il periodo (n): 5
M5 = 1350.0

Scrivi il programma ArithmeticProgression utile per calcolare i termini di una progressione aritmetica. Il programma deve funzionare nel modo seguente:

1. Chiede di inserire il valore del primo termine ($a_1$)

2. Se il valore inserito non è un numero intero stampa il messaggio:

    Valore a1 non valido "<valore>"   e ricomincia dal punto 1.
   

3. Chiede di inserire la ragione ($r$)

4. Se il valore inserito non è un numero intero stampa:

    Valore r non valido "<valore>"   e ricomincia dal punto 3.
   

5. Chiede di inserire il numero di termini da stampare (N)

6. Se il valore inserito non è un numero intero stampa:

    Valore N non valido "<valore>"   e ricomincia dal punto 5.
   

7. Se il valore inserito è inferiore a 1 stampa:

    Il numero di termini deve essere maggiore di 0   e ricomincia dal punto 5.
   

8. Stampa i primi N termini della progressione aritmetica

Esempio 1:

Inserire primo termine (a1): 1
Inserire ragione (r): 2
Inserire numero di termini (N): 10
1, 3, 5, 7, 9, 11, 13, 15, 17, 19.

Esempio 2:

Inserire primo termine (a1): bau
Valore a1 non valido "bau"
Inserire primo termine (a1): 1
Inserire ragione (r): miao
Valore r non valido "miao"
Inserire ragione (r): 2
Inserire numero di termini (N): muhh
Valore N non valido "muhh"
Inserire numero di termini (N): 0
Il numero di termini deve essere maggiore di 0
Inserire numero di termini (N): 5
1, 3, 5, 7, 9.

Scrivi il programma Arrotondatore che calcola il valore del primo argomento arrotondato al multiplo più vicino del secondo argomento:

java Arrotondatore 1.2781 0.3
1.2	

java Arrotondatore 24 5
25.0

java Arrotondatore 1.2781 0.1
1.3

Scrivi il programma CalcolatoreMedia che calcola la media di tutte le note valide passate come argomenti da linea di comando (scarta quelle non valide) e la stampa arrotondandola al decimo di punto più vicino.

java CalcolatoreMedia 1.72 4.21 5 -2 cane 6

Nota 1:     1.72
Nota 2:     4.21
Nota 3:     5.0
Nota 4:     6.0
----------------
Media:      4.2   

Opzione: Stampare anche gli elementi scartati separati da virgole (','). Esempio:

java CalcolatoreMedia 1.72 4.21 5 -2 cane 6

Nota 1:     1.72
Nota 2:     4.21
Nota 3:     5.0
Nota 4:     6.0
----------------
Media:      4.2   

Argomenti scartati: -2, cane

Scrivi la classe Java ZigZag. Tale classe deve utilizzare il carattere ‘/’ (slash) e il carattere ‘' (back-slash) per disegnare un tratteggio verticale infinito. Il disegno deve essere realizzato esattamente come illustrato nell’esempio seguente:

>java ZigZag
\
 \
  \
   \
   /
  /
 /
/
\
 \
  \
   \
   /
  /
 /
/
\
 \
  \
   \
   /
  /
 /
/
...

Scrivi il programma Istogramma che stampa un grafico a colonne rappresentando una colonna per ogni nota scolastica passata come argomento:

java Istogramma 1.5 4 3.2 6

6           *
5.5         *
5           *
4.5         *
4       *   *
3.5     *   *
3       * * *
2.5     * * *
2       * * *
1.5   * * * * 
1     * * * *

La classe Fibonacci deve generare i primi mille numeri della celeberrima successione di Fibonacci (wiki).

Tale successione inizia con i due valori 0 e 1 (detti F0 e F1). Il valore seguente (F2) si ottiene sommando i due precedenti (0 + 1 = 1), il quarto valore (F3) si ottiene sommado tra loro il F1 e F2 (1 + 1 = 2) e via dicendo. I primi valori della serie sono 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 (F10),…

Scrivi il programma Bisestili che stampa tutti gli anni bisestili (wiki) tra il 1600 e il 3000. Esempio:

1600, 1604, 1608, 1612, 1616, 1620, ... 2976, 2980, 2984, 2988, 2992, 2996.

Scrivere la classe Asciigator che chiede all’utente di digitare un stringa di testo e poi stampa ogni carattere contenuto nella stringa introdotta e il relativo codice Unicode (in decimale e in esadecimale).

Ad esempio per ABCDEF1234567890 il programma produce l’output seguente:

Introdurre un testo:
ABCDEF1234567890

char:	'A'	'B'	'C'	'D'	'E'	'F'	'1'	'2'	'3'	'4'	'5'	'6'	'7'	'8'	'9'	'0'	
dec:	65	66	67	68	69	70	49	50	51	52	53	54	55	56	57	48	
hex:	41	42	43	44	45	46	31	32	33	34	35	36	37	38	39	30	

Mentre per Hello world!:

Introdurre un testo:
Hello world!

char:	'H'	'e'	'l'	'l'	'o'	' '	'w'	'o'	'r'	'l'	'd'	'!'	
dec:	72	101	108	108	111	32	119	111	114	108	100	33	
hex:	48	65	6c	6c	6f	20	77	6f	72	6c	64	21

Scrivi il programma UnicodeTest che stampa a terminale i primi 1000 caratteri unicode partendo dal primo carattere stampabile che è il carattere blank (‘ ‘). Il programma stampa il codice esadecimale e il relativo carattere:

Char: 20 ==> ' '
Char: 21 ==> '!'
Char: 22 ==> '"'
Char: 23 ==> '#'
Char: 24 ==> '$'
Char: 25 ==> '%'
Char: 26 ==> '&'
Char: 27 ==> '''
Char: 28 ==> '('
Char: 29 ==> ')'
Char: 2a ==> '*'
Char: 2b ==> '+'
Char: 2c ==> ','
Char: 2d ==> '-'
Char: 2e ==> '.'
Char: 2f ==> '/'
Char: 30 ==> '0'
Char: 31 ==> '1'
Char: 32 ==> '2'
Char: 33 ==> '3'
Char: 34 ==> '4'
Char: 35 ==> '5'
Char: 36 ==> '6'
Char: 37 ==> '7'
Char: 38 ==> '8'
Char: 39 ==> '9'
Char: 3a ==> ':'
Char: 3b ==> ';'
Char: 3c ==> '<'
Char: 3d ==> '='
Char: 3e ==> '>'
Char: 3f ==> '?'
Char: 40 ==> '@'
Char: 41 ==> 'A'
Char: 42 ==> 'B'
Char: 43 ==> 'C'
Char: 44 ==> 'D'
Char: 45 ==> 'E'
Char: 46 ==> 'F'
Char: 47 ==> 'G'
...
Char: 37b ==> 'ͻ'
Char: 37c ==> 'ͼ'
Char: 37d ==> 'ͽ'
...
Char: 3e4 ==> 'Ϥ'
Char: 3e5 ==> 'ϥ'
Char: 3e6 ==> 'Ϧ'
Char: 3e7 ==> 'ϧ'

Scrivi la classe MathTool contenente i metodi:

public static int pow(int base, int exp)

Tale metodo calcola l’elevazione a potenza (base elevato exp).

public static int factorial(int n)

Che ritorna il fattoriale di n. Ad esempio il fattoriale di 3 è 6 (3 * 2 * 1 = 6).

public static int digitAt(long number, int index)

Che ritorna il valore della cifra alla posizione index dentro a number. Ad esempio digitAt(123456, 0) ritorna 1, mentre digitAt(123456, 3) ritorna 4. Per risolvere questo problema è vietato ricorrere alla trasformazione di number in una stringa.

Scrivi il programma Java ElevazioneAPotenza che calcola l’elevazione a potenza del valore intero passato come primo argomento per il secondo argomento intero.

Esempio:

> java ElevazioneAPotenza 2 3 
2 ^ 3 = 8

Scrivi un decodificatore capace decifrare una stringa in alfabeto farfallino.

Esempio:

>java DeFarfallinatore Lefe frafagofolefe sofonofo mafatufurefe
Le fragole sono mature

Scrivi il programma Farfallinatore che codifichi una stringa introdotta dall’utente in alfabeto farfallino (se non conosci l’alfabeto farfallino vedi wikipedia).

Esempio:

>java Farfallinatore Tanto va la gatta al lardo
Tafantofo vafa lafa gafattafa afal lafardofo

Scrivi la classe WordShaker che chiede all’utente di inserire una frase e poi la stampa scambiando il primo con in secondo carattere, il terzo con il quarto, il quinto con il sesto e via dicendo. Se il numero di caratteri è dispari l’ultimo carattere viene stampato nella sua posizione originale.

Qualche esempio:

• cane diventa acen
• gatto diventa agtto
• tanto va la gatta al lardo diventa attn oavl aagtt alal raod
• abcde diventa badce

Esempio di output:

Inserire una frase: Asta la vista!
sAatl  aivts!a

Scrivi la class SentenceSplitter che chiede all’utente di inserire una frase e poi la stampa alternandone i caratteri su due righe come mostrato negli esempi seguenti.

Esempio di output:

Inserire una frase: cane
c n 
 a e

oppure:

Inserire una frase: mele cotogne
m l   o o n 
 e e c t g e

o ancora:

Inserire una frase: Tanto va la gatta al lardo.
T n o v   a g t a a   a d .
 a t   a l   a t   l l r o 

Scrivi la classe DoubleCounter che chiede all’utente di inserire una parola e stampa il conteggio delle coppie caratteri consecutivi uguali (non sensibile alle maiuscole) contenute nella parola. Qualche esempio:

• per la parola cane il conteggio vale 0
• per gatto vale 1 (tt)
• per caMmMicia vale 2 (Mm e mM)
• per abbacchio vale 2 (bb e cc)
• per Ooteca vale 1 (Oo)

Esempio di output:

Inserire una parola: Zzzzummm
Coppie: 5

Scrivi il programma Java TriangoloRettangolo. Il programma chiede all’utente di introdurre (come argomento da linea di comando o interattivamente) un numero intero positivo (N) e poi disegna a terminale un triangolo rettangolo pieno composto di asterischi (‘*’) con il lato lungo N:

Per N pari a 3 il programma stampa:

*
** 
***

Per N pari a 5 il programma stampa:

*
**
***
****
*****

E via dicendo…

Scrivi il programma Java QuadratoPieno. Il programma chiede all’utente di introdurre (come argomento da linea di comando o interattivamente) un numero intero positivo (N) e poi disegna a terminale un quadrato pieno composto di asterischi (‘*’) con il lato lungo N:

Per N pari a 3 il programma stampa:

***
***
***

Per N pari a 5 il programma stampa:

*****
*****
*****
*****
*****

E via dicendo…

Scrivi la classe FrameName che chiede all’utente di inserire un testo e po lo stampa incorniciandolo utilizzando i caratteri Unicode della pagina U2500.

Qualche esempio:

Inserire testo: Alb
┌─────┐
│ Alb │
└─────┘

Oppure:

Inserire testo: Andrea
┌────────┐
│ Andrea │
└────────┘

O ancora:

Inserire testo: Tanto va la gatta al lardo...
┌───────────────────────────────┐
│ Tanto va la gatta al lardo... │
└───────────────────────────────┘

Nota: Su alcune shell i caratteri unicode potrebbero essere rappresentati in modo errato.

Scrivi il programma TridenteSpeculare . Il programma chiede all’utente di introdurre un numero intero positivo (N) e poi disegna a terminale un tridente (riflesso verticalmente) composto di asterischi (‘*’) con l’altezza pari ad N:

Per N pari a 3 il programma stampa:

* *** *** *
** ** ** **
*** * * ***

*** * * ***
** ** ** **
* *** *** *

Per N pari a 4 il programma stampa:

* **** **** *
** *** *** **
*** ** ** ***
**** * * ****

**** * * ****
*** ** ** ***
** *** *** **
* **** **** *

Per 5:

* ***** ***** *
** **** **** **
*** *** *** ***
**** ** ** ****
***** * * *****

***** * * *****
**** ** ** ****
*** *** *** ***
** **** **** **
* ***** ***** *

E via dicendo…

Scrivi il programma Java Tridente. Il programma chiede all’utente di introdurre un numero intero positivo (N) e poi disegna a terminale un tridente composto di asterischi (‘*’) con l’altezza pari ad N:

Per N pari a 3 il programma stampa:

* *** *** *
** ** ** **
*** * * ***

Per N pari a 4 il programma stampa:

* **** **** *
** *** *** **
*** ** ** ***
**** * * ****

Per 5:

* ***** ***** *
** **** **** **
*** *** *** ***
**** ** ** ****
***** * * *****

E via dicendo…

Scrivi il programma Java Merlo. Il programma chiede all’utente di introdurre (come argomento da linea di comando o interattivamente) un numero intero positivo (N) e poi disegna a terminale un merlo (elemento tipico dell’architettura militare medievale) composto di asterischi (‘*’) con l’altezza pari ad N.

Il programma accetta esclusivamente valori numerici interi positivi.

Se l’utente fornisce un dato non accettabile (non numerico o negativo) il programma produce il messaggio “inserire solo numeri positivi”.

Per N pari a 3 il programma stampa:

*   *
** **
*****

Per N pari a 4 il programma stampa:

*     *
**   **
*** ***
*******

E via dicendo…

Scrivi la classe Ics che disegna a terminale una X composta di asterischi. Il programma chiede all’utente di introdurre (come argomento da linea di comando o interattivamente) un numero intero (N).

Il programma accetta esclusivamente valori numerici interi positivi dispari.

Se l’utente fornisce un dato non accettabile (non numerico, pari o negativo) il programma produce il messaggio “inserire solo numeri positivi dispari”.

Per N pari a 3 il programma stampa:

* *
 *
* * 

Per N pari a 5 il programma stampa:

*   *
 * *
  *
 * *
*   *

E via dicendo..

Scrivi il programma Java Ecorc. Il programma chiede all’utente di introdurre (come argomento da linea di comando o interattivamente) un numero intero (N) e poi disegna a terminale una croce in negativo.

Il programma accetta esclusivamente valori numerici interi positivi dispari.

Se l’utente fornisce un dato non accettabile (non numerico, pari o negativo) il programma produce il messaggio “inserire solo numeri positivi dispari”.

Per N pari a 3 il programma stampa:

* *

* * 

Per N pari a 5 il programma stampa:

** **
** **

** **
** **

Per N pari a 7 il programma stampa:

*** ***
*** ***
*** ***

*** ***
*** ***
*** ***

E via dicendo..

Scrivi il programma Java Croce. Il programma chiede all’utente di introdurre (come argomento da linea di comando o interattivamente) un numero intero positivo (N) e poi disegna a terminale una croce composta di asterischi (‘*’). La dimensione della croce è definita dal valore immesso.

Il programma accetta esclusivamente valori numerici interi positivi pari.

Se l’utente fornisce un dato non accettabile (non numerico, dispari o negativo) il programma produce il messaggio “inserire solo numeri positivi pari”.

Per N pari a 4 il programma stampa:

 **
****
****
 **

Per N pari a 10 il programma stampa:

     **
     **
     **
     **
 **********
 **********
     **
     **
     **
     **

E via dicendo…

Scrivi il programma Java TriangoloIsoscele . Il programma chiede all’utente di introdurre (come argomento da linea di comando o interattivamente) un numero intero positivo dispari (N) e poi disegna a terminale un triangolo vuoto composto di asterischi (‘*’) avente la base di lunghezza pari ad N.

Il programma accetta esclusivamente valori numerici interi positivi dispari.

Se l’utente fornisce un dato non accettabile (non numerico, pari o negativo) il programma produce il messaggio “inserire solo numeri positivi dispari”.

Per N pari a 3 il programma stampa:

 *
***

Per N pari a 5 il programma stampa:

  *
 * * 
*****

E via dicendo…

Scrivi il programma Java TriangoloRettangoloVuoto. Il programma chiede all’utente di introdurre (come argomento da linea di comando o interattivamente) un numero intero positivo (N) e poi disegna a terminale un triangolo rettangolo vuoto composto di asterischi (‘*’) con il lato lungo N:

Per N pari a 3 il programma stampa:

*
** 
***

Per N pari a 5 il programma stampa:

*
**
* *
*  *
*****

E via dicendo…

Scrivi il programma Java QuadratoVuoto. Il programma chiede all’utente di introdurre (come argomento da linea di comando o interattivamente) un numero intero positivo (N) e poi disegna a terminale un quadrato vuoto composto di asterischi (‘*’) con il lato lungo N:

Per N pari a 3 il programma stampa:

***
* *
***

Per N pari a 5 il programma stampa:

*****
*   *
*   *
*   *
*****

E via dicendo…

Scrivi il programma Rotator che chiede all’utente di disegnare una figura bidimensionale e poi la stampa ruotandola (applica un rotazione di 90° in senso orario e una simmetria speculare verticale) come mostrato negli esempi seguenti.

La figura introdotta può avere una dimensione massima di 10 x 10 (10 righe e 10 colonne).

L’introduzione della figura termina con successo quando l’utente introduce una riga vuota e preme enter oppure quando la dimensione verticale della figura raggiunge le 10 righe.

Se durante l’introduzione l’utente introduce una riga più lunga di 10 caratteri il programma stampa il messaggio Linea troppo lunga, riprova: e l’introduzione ricomincia da capo.

Qualche esempio:

Inserire un disegno (enter per terminare): 
abcd
efgh

Rotazione:

ae
bf
cg
dh

Oppure:

Inserire un disegno (enter per terminare): 
     *
     ***
*********
     ***
     *

Rotazione:

  *  
  *  
  *  
  *  
  *  
*****
 *** 
 *** 
  *  

Oppure per un riga troppo lunga:

Inserire un disegno (enter per terminare): 
abcdefghjkklm
Linea troppo lunga, riprova:
12345
6   7
89ABC

Rotazione:

168
2 9
3 A
4 B
57C

Scrivi la classe Patternizer che chiede all’utente di inserire un pattern che servirà da modello per disegnare una figura bidimensionale. L’utente introduce la sequenza di caratteri da stampare su di una sola riga utilizzando il carattere 'g' per indicare i punti in cui andare a capo.

Ad esempio la sequenza " /\g/ \g|__|" produce il disegno seguente:

 /\
/  \
|__|

Il programma stampa il disegno in uno spazio cartesiano in cui devono comparire le coordinate orizzontali e verticali come mostrato negli esempi seguenti:

Inserire pattern (g per new line):
****g*  *g*  *g****
 0123
0****
1*  *
2*  *
3****

Oppure:

Inserire pattern (g per new line):
*********g.*.....*.g..*...*..g...*.*...g....*....
 012345678
0*********
1.*.....*.
2..*...*..
3...*.*...
4....*....

La figura contenuta nel pattern deve avere una larghezza massima di 10 caratteri. Se il pattern fornito non rispetta questa regola, il programma stampa il messaggio Riga <riga> troppo lunga (max 10 char), indicando il numero della riga non valida e poi ripete la richiesta iniziale. Esempio:

Inserire pattern (g per new line):
*.*.*.*.*.*g***g---*g
Riga 0 troppo lunga (max 10 char)
Inserire pattern (g per new line):
/\/\/\g\/\/\/
 012345
0/\/\/\
1\/\/\/

Scrivi il programma Filler che chiede all’utente di disegnare una figura bidimensionale chiusa composta di asterischi ('*'). L’introduzione della figura termina quando l’utente introduce una riga vuota e preme enter. Il programma stampa poi la figura riempiendone le cavità orizzontali, come mostrato negli esempi seguenti. Qualche esempio:

Disegnare figura chiusa (enter per terminare): 
********
*      *
*      *
********

Figura piena:

********
********
********
********

Oppure:

Disegnare figura chiusa (enter per terminare): 
      *
  *       *
*           *
  *       *
      *

Figura piena:
      *
  *********
*************
  *********
      *

Se viene immessa una riga non vuota che non contiene nemmeno un asterisco, viene stampato il messaggio Linea non valida! e poi ripete la richiesta iniziale. Esempio:

Disegnare figura chiusa (enter per terminare): 
kasdjfnkasfd
Linea non valida! Disegnare figura chiusa (enter per terminare): 
   *
  * *
 *****  
   * 

Figura piena:
   *
  ***
 *****  
   * 

Scrivi la class Coordinator che:

1. Chiede all’utente di inserire la coordinata di riga (intero, valore minimo 0, valore massimo 4).

2. Se il valore non è valido stampa un messaggio di errore e ricomincia dal punto 1.

3. Chiede di inserire la coordinata di colonna (intero, valore minimo 0, valore massimo 4).

4. Se il valore non è valido stampa un messaggio di errore e ricomincia dal punto 3.

5. Stampa a terminale un piano cartesiano (dimensione 5 x 5) con una X alla coordinata immessa (vedi esempi).

I messaggi di errore da stampare (ai punti 2. e 4.) sono i seguenti:

• Se il valore immesso è troppo basso: "Valore troppo piccolo <valore>"
• Se il valore immesso è troppo alto: "Valore troppo grande <valore>"
• Se il valore non è un numero: "Inserire solo numeri interi"

Esempio di output:

Inserire coordinata riga [0;4]: 2
Inserire coordinata colonna [0;4]: 2
 01234
0     
1     
2  X  
3     
4             

Oppure:

Inserire coordinata riga [0;4]: -1
Valore troppo piccolo -1
Inserire coordinata riga [0;4]: 0
Inserire coordinata colonna [0;4]: 100
Valore troppo grande 100
Inserire coordinata colonna [0;4]: zero
Inserire solo numeri interi
Inserire coordinata colonna [0;4]: 0
 01234
0X    
1     
2     
3     
4 

Scrivi il gioco interattivo MorraCinese. Il programma chiede di inserire il punteggio massimo, poi il gioco comincia. Vince chi raggiunge prima il punteggio massimo.

1. Il programma chiede di inserire il punteggio massimo. Sono ammessi solo valori nel range [1;10].
2. Se l’utente inserisce un valore non valido, ricomincia dal punto 1.
3. Chiede all’utente di inserire la sua giocata (1 per carta, 2 per sasso, 3 per forbice).
4. Se l’utente inserisce un valore non valido, ricomincia dal punto 3.
5. Il programma estrae a sorte la propria giocata (1 per carta, 2 per sasso, 3 per forbice).
6. Il programma visualizza le due giocate e, se ve ne è uno, il vincitore della mano corrente (player o CPU) e il punteggio attuale dei due giocatori.
7. Se nessuno ha raggiunto il punteggio massimo il programma prosegue dal punto 3.
8. Se un giocatore ha raggiunto il punteggio massimo il programma stampa il nome del vincitore (player o CPU) e prosegue dal punto 9.
9. Il programma chiede se si vuole giocare di nuovo (0 per continuare, 1 per terminare).
10. Se l’utente inserisce un valore non valido, ricomincia dal punto 9.
11. Se l’utente inserisce 0 il programma ricomincia dal punto 1.
12. Se l’utente inserisce 1 il programma termina.

Esempio:

Oppure, se la vostra console supporta Unicode:

Scrivi il programma interattivo Butterflyzer che permetta di codificare e decodificare messaggi in alfabeto farfallino.

1. Inizialmente il programma propone di scegliere la funzione ('c' per codificare, 'd' per decodificare, 'q' per terminare),
2. Se la scelta digitata non è valida ricomincia dal punto 1.
3. Se la scelta è 'q' il programma termina.
4. Se la scelta è 'c', chiede all’utente di digitare una stringa di testo da codificare e poi stampa il messaggio codificato.
5. Se la scelta è 'd', chiede all’utente di digitare il messagio da decodificare e poi stampa il testo decodificato.
6. Il programma ricomincia dal punto 1.

Esempio:

$ java Butterflyzer
Codificatore/decodificatore alfabeto Farfallino
Premi 'c' per codificare un messaggio
Premi 'd' per decodificare un messaggio
Premi 'q' per uscire
Scelta: x
Scelta non valida 'x'

Codificatore/decodificatore alfabeto Farfallino
Premi 'c' per codificare un messaggio
Premi 'd' per decodificare un messaggio
Premi 'q' per uscire
Scelta: c
Inserire testo da codificare: Tanto va la gatta al lardo
Messaggio codificato: Tafantofo vafa lafa gafattafa afal lafardofo

Codificatore/decodificatore alfabeto Farfallino
Premi 'c' per codificare un messaggio
Premi 'd' per decodificare un messaggio
Premi 'q' per uscire
Scelta: d
Messaggio da decodificare: Lefe frafagofolefe sofonofo mafatufurefe
Testo decodificato: Le fragole sono mature

Codificatore/decodificatore alfabeto Farfallino
Premi 'c' per codificare un messaggio
Premi 'd' per decodificare un messaggio
Premi 'q' per uscire
Scelta: q
$

Scrivi il programma Cerchio che chiede all’utente di introdurre un numero intero positivo (N) e poi disegna a terminale un cerchio di raggio pari ad N:

Per N pari a 2 il programma stampa:

    * * *   
  *       * 
  *   x   * 
  *       * 
    * * * 

Per un raggio pari a 3:

      * * *     
    *       *   
  *           * 
  *     x     * 
  *           * 
    *       *   
      * * *  

Per 7:

            * * * * *           
        * *           * *       
      *                   *     
    *                       *   
    *                       *   
  *                           * 
  *                           * 
  *             x             * 
  *                           * 
  *                           * 
    *                       *   
    *                       *   
      *                   *     
        * *           * *       
            * * * * *   

E via dicendo…

Per compensare la forma rettangolare dei caratteri e conferire maggiore rotondità al cerchio, raddoppiare la larghezza del disegno. Ad esempio per un raggio pari a 3:

Scrivi la classe AdvancedStringTool contenente i metodi desctitti in seguito:

isLetter

public static boolean isLetter(char c)

Ritorna true se il carattere c è una lettera, mentre ritorna false In caso contrario.

isConsonant

public static boolean isConsonant(char c)

Ritorna true se il carattere c è una consonante, false altrimenti.

isVowel

public static boolean isVowel(char c)

Ritorna true se c è una vocale, mentre ritorna false in tutti gli altri casi.

countVowels

public static int countVowels(String text)

Ritorna il numero di vocali presenti nella stringa text. Ad esempio countVowels("NOOOOOO") ritorna 6.

countConsonants

public static int countConsonants(String text)

Tale metodo ritorna il numero di consonanti presenti nella stringa text. Ad esempio countConsonants("NOOOOOO") ritorna 1.

vowelize

public static String vowelize(String text)

Ritorna una stringa contenente solamente le vocali della stringa text. Ad esempio vowelize("casa") ritorna "aa", mentre vowelize("lunotto") ritorna "uoo".

isAlternative

public static boolean isAlternative(String s)

Tale metodo ritorna true se la stringa s contiene consonanti e vocali alternate (es. isAlternative("patata") ritorna true).

countInString

public static int countInString(String text, char c)

Tale metodo conta quante volte il carattere c è presente nella stringa text.

isAnagram

public static boolean isAnagram(String firstWord, String secondWord)

Ritorna true se firstWord è un anagramma di secondWord, altrimenti ritorna false. Esempio isAnagram("calendario","locandiera") ritorna true.

Scrivi la classe NameFramer contenente il metodo:

pubic static String frameName(String name, char c, int width)

che ritorna una stringa contenente la stringa name incorniciata nel carattere c utilizzato con uno spessore width.

Ad esempio frameName("Piero",'*',2) ritorna la stringa:

*********
*********
**Piero**
*********
*********

mentre frameName("Andrea",'$',1) ritorna la stringa:

$$$$$$$$
$Andrea$
$$$$$$$$