LIP-06 - Esercitazione #9
Istruzioni generali
L'esercitazione si svolge con le macchine isolate dalla rete, pertanto non è possibile collegarsi al proprio account, e non si ha accesso alla propria home-directory, né ai servizi di rete. Selezionare IceWM come tipo di sessione. Fare login con username e password indicate dal docente.

Il web browser può essere utilizzato solo localmente. Per visualizzare le pagine web del corso potete accedere alla loro versione locale. È disponibile localmente anche la documentazione di Java (oltre a quella disponibile in Eclipse).

Sviluppare i programmi richiesti utilizzando Eclipse: nell'account in cui lavorate è predisposto il progetto LIP che contiene già le classi Input.java e ArrayUtils.java.

Alla fine dell'esercitazione fare logout SENZA spedire gli esercizi svolti al docente: gli esercizi verranno prelevati automaticamente.

I testi dell'esercitazione e i programmi da voi svolti verranno messi in linea nei prossimi giorni, in modo che possiate continuare a lavorarci.

Siete invitati a svolgere gli esercizi in modo autonomo. Tuttavia, trattandosi di un'esercitazione, potete chiedere aiuto a docente e assistenti.
Questo non sarà possibile durante il compitino del 14 dicembre, durante il quale varranno le seguenti regole:

  • Gli esercizi devono essere svolti in maniera autonoma. Leggete attentamente i testi e chiedete aiuto ai docenti in caso di problemi o di chiarimenti.

  • NON È CONSENTITA la consultazione di appunti e libri.

  • NON È CONSENTITO l'impiego di dispositivi elettronici portatili (cellulari, palmari, etc.) e l'uso di dispositivi di memoria (floppy disk, CD, etc.).

  • NON È CONSENTITO LASCIARE L'AULA DURANTE LE DUE ORE DI SVOLGIMENTO DELL'ESAME.

Esercizi

Istruzioni

  • Scrivere il proprio nome, cognome ed indirizzo di email all'inizio di OGNI file, in un opportuno commento.

  • Per gli esercizi che richiedono di leggere dei dati in input da tastiera, usare la classe Input.java. Un esempio di uso dei metodi di questa classe č contenuto nella classe EuroInput.java. Usare liberamente i metodi della classe ArrayUtils. Attenzione: le classi Input e ArrayUtils non devono essere modificate: infatti non verranno considerate in fase di correzione, e quindi eventuali modifiche andranno perse.

  • Scrivere i programmi in modo che l'interazione con l'utente sia il pių simile possibile a quella mostrata negli esempi di esecuzione.

  • Spiegare in un commento la scelta delle eventuali istruzioni iterative utilizzate.

  • [A1]   Scrivere una classe A1 con un metodo main che riempie un array di interi e stampa la somma dei valori inseriti, SOMMANDO UNA SOLA VOLTA EVENTUALI VALORI DUPLICATI e SENZA MODIFICARE L'ARRAY.
    Ad esempio, se l'array viene creato con dimensione 10 e riempito con i valori  1, 3, 1, 4, 2, 2, 4, 1, 5, 3  allora bisogna sommare  1 + 3 + 4 + 2 + 5, ottenendo come output il valore 15.

  • [A2] Scrivere una classe A2 con i seguenti metodi statici:

    • public static boolean isNumber(char a)
      restituisce vero se il carattere passato come argomento è una cifra (da 0 a 9), falso altrimenti;

    • public static boolean twoNumber(char[] a)
      restituisce true se l'array di caratteri contiene due cifre in posizioni adiacenti, falso altrimenti.

    Scrivere quindi la classe A2Test con un metodo main che legge una stringa, la converte in array di caratteri (possibilmente usando un opportuno metodo di String) e stampa un messaggio che indica se la stringa contiene due cifre consecutive oppure no, utilizzando i metodi della classe A2.

    Esempi di interazione con il programma (in blu l'input dell'utente): 
    Dammi una stringa: 44 gatti in fila per 6 con il resto di due
Contiene due cifre consecutive
    		 
    Dammi una stringa: in fila per 6 con il resto di 2
Non contiene due cifre consecutive

  • [A3]  Scrivere la classe A3 che contiene il metodo statico minoriRec con l'intestazione:

    • public static int minoriRec(int[] arr, int num)

    Il metodo minoriRec deve restituire il numero di elementi dell'array arr che sono minori o uguali a num, utilizzando un algoritmo ricorsivo.

    Suggerimento: Si prenda spunto dal metodo maxRicorsivo visto a lezione, usando un metodo ausiliario (privato) con un parametro in più che indica la porzione dell'array ancora da visitare. Si scriva esplicitamente (in un commento) la definizione ricorsiva utilizzata, identificando con chiarezza il caso base e quello ricorsivo.

    Per testare il metodo, usare il programma TestA3 che invoca il metodo minoriRec su opportuni parametri.

    • Esempio di esecuzione del programma TestA3 
    Test sull'array [ ] 
e num uguale a 9
Esito: 0

Test sull'array  [ 10 ] 
e num uguale a 9
Esito: 0

Test sull'array [ 14 3 57 29 9 12 ] 
e num uguale a 10
Esito: 2

Test sull'array  [ 14 3 57 29 9 12 ]  
e num uguale a 1
Esito: 0

Test sull'array [  14 3 57 29 9 12 13 ] 
e num uguale a 57
Esito: 7

  • [A4] Scrivere una classe A4 con il seguenti metodi statici su stringhe:

    • public static void reverse(char[] c)
      inverte il contenuto dell'array passato per argomento. Notare che il metodo non restituisce nulla: viene modificato l'array passato per parametro

    • public static String reverse(String s)
      restituisce la stringa rovesciata;
      INSERIRE UN COMMENTO CON LA RISPOSTA AL SEGUENTE QUESITO: Perché il metodo non può avere tipo void analogamente a quanto fatto per il metodo reverse precedente?

    • public static String min(String a, String b, String c)
      restituisce la stringa che precede le altre due nell'ordinamento lessicografico.
      Suggerimento: definire prima un metodo con firma min(String,String) e utilizzarlo poi nella definizione del metodo min(String,String,String).

    Testare i metodi usando la classe TestA4 che contiene un metodo main che legge tre stringhe e le usa per testare i metodi della classe A4.

    Esempio di interazione con il programma : 
    Di seguito dammi 3 stringhe,
scrivi la 1a stringa: pippo
scrivi la 2a stringa: pluto
scrivi la 3a stringa: paperino

Prima rovesciata con reverse(char[]): oppip
Seconda rovesciata con reverse(String): otulp
Min tra pippo, pluto e  paperino: paperino
Min tra pippo, pluto e  paperino rovesciate: onirepap

  • [A5]  Scrivere la classe A5 contenente il metodo statico minLocali con l'intestazione:

    • public static int minLocali(int[] arr)

    Il metodo minLocali deve restituire il numero totale di minimi locali che sono presenti nell'array arr passato per argomento. Un elemento dell'array è un minimo locale se è strettamente minore dell'elemento che lo precede (se esiste), e strettamente minore di quello che lo segue (se esiste). In particolare, si noti che se l'array ha un solo elemento, allora questo è sicuramente un minimo locale.

    Per testare il metodo utilizzare il programma TestA5 . Se il metodo è scritto correttamente, l'output dovrebbe essere esattamente il seguente:

    • Output del programma TestA5 
    *****     Test di minLocali(int[])    *****
Array: [ ]
Risultato di minLocali: 0
*******************************************
Array: [ 3 4 5 ]
Risultato di minLocali: 1
*******************************************
Array: [ 10 20 10 20 10 ]
Risultato di minLocali: 3
*******************************************
Array: [ 30 20 10 20 30 ]
Risultato di minLocali: 1
*******************************************
Array: [ 30 30 30 31 32 ]
Risultato di minLocali: 0
*******************************************

  • [Extra]   Scrivere la classe A6 che contiene il metodo statico sommaPesRec con l'intestazione:

    • public static int sommaPesRec(int[] arr)

    Il metodo sommaPesRec deve restituire il risultato di ∑i=0n-1 ((-1)i * a[i]), dove n è la lunghezza dell'array arr, utilizzando un algoritmo ricorsivo.

    Si scriva esplicitamente (in un commento) la definizione ricorsiva utilizzata, identificando con chiarezza il caso base e quello ricorsivo.

    Per testare il metodo, scrivere il programma A6Test che chiede all'utente i valori per riempire un array di interi e stampa (con opportuni commenti) il contenuto dell'array, e infine la somma pesata degli elementi dell'array.

    • Esempio di esecuzione del programma A6Test (input utente in verde) 
    Riempimento array...
Dimensione array (intero positivo): 5
Dammi l'intero in posizione 0: 2
Dammi l'intero in posizione 1: 40
Dammi l'intero in posizione 2: 3
Dammi l'intero in posizione 3: -10
Dammi l'intero in posizione 4: -5
Contenuto dell'array: [ 2 40 3 -10 -5 ]
Risultato di sommaPesRec: -30