/**
    Classe della Prova di Esame di Programmazione I e Laboratorio
    del 12 dicembre 2003
*/

public class ProvaArrayStringhe {

    /**
    deve prendere come parametro un array di elementi di tipo stringa
    e una stringa e restituire true se l'array contiene almeno tre
    occorenze della stringa data, false altrimenti
    @param a array di stringhe assunto non vuoto e con tutti gli
    elementi inizializzati correttamente
    @param altraStringa stringa data, assunta inizializzata
    correttamente
    @return vero se vi sono almeno tre occorrenze di altraStringa
    false altrimenti
    */
    public static boolean treOccorrenze(String[] a, String altraStringa) {
        int numeroOccorrenze = 0;
        int i = 0;
        while ((i < a.length) && (numeroOccorrenze < 3)) {
            if (a[i].equals(altraStringa))
                numeroOccorrenze++;
            i++;
        }
        return (numeroOccorrenze == 3);
    }

    /**
    deve prendere come parametro un array di elementi di tipo stringa
    e una stringa e restituire l'indice della prima occorrenza della
    stringa data, -1 altrimenti
    @param a array di stringhe assunto non vuoto e con tutti gli
    elementi inizializzati correttamente
    @param altraStringa stringa data, assunta inizializzata
    correttamente
    @return un intero
    */
    public static int indicePrimaOccorrenzaI(String[] a, String altraStringa) {
        boolean trovato = false;
        int i = 0;
        while ((i < a.length) && !trovato)
            if (a[i].equals(altraStringa))
                trovato = true;
            else i++;
        if (trovato)
            return i;
        else
            return -1;
    }

    /**
    deve prendere come parametro un array di elementi di tipo stringa
    e una stringa e restituire l'indice della prima occorrenza della
    stringa data, -1 altrimenti
    Questo metodo e` una soluzione alternativa al precedente indicePrimaOccorrenzaI
    @param a - array di stringhe assunto non vuoto e con tutti gli
    elementi inizializzati correttamente
    @param altraStringa - stringa data, assunta inizializzata
    correttamente
    @return un intero
    */
    public static int indicePrimaOccorrenzaII(String[] a, String altraStringa) {
        int i = 0;
        while (i < a.length)
            if (a[i].equals(altraStringa))
                return i;
            else i++;
        return -1;
    }

    /**
    deve prendere come parametro un array di elementi di tipo stringa
    e un numero intero e restituire true se la somma della lunghezza
    di tutte le stringhe nell'array e` maggiore del numero dato,
    false altrimenti
    @param a array di stringhe assunto non vuoto e con tutti gli
    elementi inizializzati correttamente
    @param valore intero dato
    @return true se la somma delle lunghezze delle stringhe e` maggiore
    di valore, false altrimenti
    */
    public static boolean lunghezzaMaggioreI(String[] a, int valore) {
        int sommaLunghezza = 0;
        int i = 0;
        while ((i < a.length) && (sommaLunghezza <= valore)) {
            sommaLunghezza += a[i].length();
            i++;
        }
        return (sommaLunghezza > valore);
    }

    /**
    deve prendere come parametro un array di elementi di tipo stringa
    e un numero intero e restituire true se la somma della lunghezza
    di tutte le stringhe nell'array e` maggiore del numero dato,
    false altrimenti
    Questo metodo e` una soluzione alternativa al precedente lunghezzaMaggioreI
    @param a array di stringhe assunto non vuoto e con tutti gli
    elementi inizializzati correttamente
    @param valore intero dato
    @return true se la somma delle lunghezze delle stringhe e` maggiore
    di valore, false altrimenti
    */
    public static boolean lunghezzaMaggioreII(String[] a, int valore) {
        int sommaLunghezza = 0;
        int i = 0;
        while (i < a.length) {
            sommaLunghezza += a[i].length();
            if (sommaLunghezza > valore)
                return true;
            else i++;
        }
        return false;
    }

    /**
    deve prendere come parametro un array di elementi di tipo stringa
    e un numero intero e restituire l'ultima occorrenza di una stringa
    di lunghezza superiore al numero dato se questa esiste, la stringa
    vuota altrimenti
    @param a array di stringhe assunto non vuoto e con tutti gli
    elementi inizializzati correttamente
    @param valore intero dato
    @return l'ultima occorrenza di una stringa di lunghezza maggiore di
    valore, la stringa vuote se non ci sono stringhe che soddisfano
    la lunghezza richiesta
    */
    public static String ultimaOccorrenzaI(String[] a, int valore) {
        boolean trovato = false;
        int i = a.length - 1;
        while ((i >= 0) && ! trovato) {
            if (a[i].length() > valore)
                trovato = true;
            else i--;
        }
        if (trovato)
            return a[i];
        else
            return "";
    }

    /**
    deve prendere come parametro un array di elementi di tipo stringa
    e un numero intero e restituire l'ultima occorrenza di una stringa
    di lunghezza superiore al numero dato se questa esiste, la stringa
    vuota altrimenti
    Questo metodo e` una soluzione alternativa al precedente ultimaOccorrenzaI
    @param a array di stringhe assunto non vuoto e con tutti gli
    elementi inizializzati correttamente
    @param valore intero dato
    @return l'ultima occorrenza di una stringa di lunghezza maggiore di
    valore, la stringa vuote se non ci sono stringhe che soddisfano
    la lunghezza richiesta
    */
    public static String ultimaOccorrenzaII(String[] a, int valore) {
        int i = a.length - 1;
        while (i >= 0) {
            if (a[i].length() > valore)
                return a[i];
            else i--;
        }
        return "";
    }


    /**
        Risultato atteso dal main:

        Tre occorrenze? false
        Tre occorrenze? true
        Indice prima occorrenza: 1
        Indice prima occorrenza: 1
        Indice prima occorrenza: -1
        Indice prima occorrenza: -1
        Lunghezza maggiore di 15? true
        Lunghezza maggiore di 50? false
        Lunghezza maggiore di 15? true
        Lunghezza maggiore di 50? false
        Ultima occorrenta stringa maggiore di 6: baldoni
        Ultima occorrenta stringa maggiore di 6: baldoni
        Ultima occorrenta stringa maggiore di 15:
        Ultima occorrenta stringa maggiore di 15:

     */
    public static void main(String[] args) {
        String[] a = new String[5];
        a[0] = "matteo";
        a[1] = "baldoni";
        a[2] = "esame";
        a[3] = "programmazione";
        a[4] = "laboratorio";
        System.out.println("Tre occorrenze? " +
            treOccorrenze(a, "matteo"));
        a[0] = "matteo";
        a[1] = "baldoni";
        a[2] = "baldoni";
        a[3] = "programmazione";
        a[4] = "baldoni";
        System.out.println("Tre occorrenze? " +
            treOccorrenze(a, "baldoni"));

        System.out.println("Indice prima occorrenza: " +
            indicePrimaOccorrenzaI(a, "baldoni"));
        System.out.println("Indice prima occorrenza: " +
            indicePrimaOccorrenzaII(a, "baldoni"));
        System.out.println("Indice prima occorrenza: " +
            indicePrimaOccorrenzaI(a, "esame"));
        System.out.println("Indice prima occorrenza: " +
            indicePrimaOccorrenzaII(a, "esame"));

        System.out.println("Lunghezza maggiore di 15? " +
            lunghezzaMaggioreI(a, 15));
        System.out.println("Lunghezza maggiore di 50? " +
            lunghezzaMaggioreI(a, 50));
        System.out.println("Lunghezza maggiore di 15? " +
            lunghezzaMaggioreII(a, 15));
        System.out.println("Lunghezza maggiore di 50? " +
            lunghezzaMaggioreII(a, 50));

        System.out.println("Ultima occorrenta stringa maggiore di 6: " +
            ultimaOccorrenzaI(a, 6));
        System.out.println("Ultima occorrenta stringa maggiore di 6: " +
            ultimaOccorrenzaII(a, 6));
        System.out.println("Ultima occorrenta stringa maggiore di 15: " +
            ultimaOccorrenzaI(a, 15));
        System.out.println("Ultima occorrenta stringa maggiore di 15: " +
            ultimaOccorrenzaII(a, 15));

    }

}