/**
    Classe della Prova di Esame di Programmazione I e Laboratorio
    del 7 gennaio 2003
*/

public class ProvaArrayStringhe2 {

    /**
    deve prendere come parametro due array di elementi di tipo stringa
    e restituire true se il primo array e` l'inverso del secondo,
    false altrimenti
    @param a primo array di stringhe, assumiano che l'array non e`
    e tutti gli elementi sono inizializzati correttamente
    @param b primo array di stringhe, assumiano che l'array non e`
    e tutti gli elementi sono inizializzati correttamente
    @return true se il primo array e` l'inverso del secondo, false
    altrimenti
    */
    public static boolean inversoI(String[] a, String[] b) {
        if (a.length != b.length)
            return false;
        boolean inverso = true;
        int i = 0;
        while ((i < a.length) && inverso) {
            if (!a[i].equals(b[a.length - 1 - i]))
                inverso = false;
            i++;
        }
        return inverso;
    }

    /**
    deve prendere come parametro due array di elementi di tipo stringa
    e restituire true se il primo array e` l'inverso del secondo,
    false altrimenti
    Questo metodo e` una soluzione alternativa al precedente inversoI 
    @param a primo array di stringhe, assumiano che l'array non e`
    e tutti gli elementi sono inizializzati correttamente
    @param b primo array di stringhe, assumiano che l'array non e`
    e tutti gli elementi sono inizializzati correttamente
    @return true se il primo array e` l'inverso del secondo, false
    altrimenti
    */
    public static boolean inversoII(String[] a, String[] b) {
        if (a.length != b.length)
            return false;
        int i = 0;
        while (i < a.length) {
            if (!a[i].equals(b[a.length - 1 - i]))
                return false;
            i++;
        }
        return true;
    }

    /**
    deve prendere come parametro due array di elementi di tipo stringa
    e restituire true se i due array non hanno mai stringhe uguali in
    posizione uguale, false altrimenti. Si noti che gli array potrebbero
    avere dimensione diversa, in questo caso verificare solo le
    posizioni in comune.
    @param a primo array di stringhe, assumiano che l'array non e`
    e tutti gli elementi sono inizializzati correttamente
    @param b primo array di stringhe, assumiano che l'array non e`
    e tutti gli elementi sono inizializzati correttamente
    @return true o false secondo specifica
    */
    public static boolean sempreDiversiI(String[] a, String[] b) {
        int limiteCheck;
        if (a.length > b.length)
            limiteCheck = b.length;
        else
            limiteCheck = a.length;
        boolean sempreDiversi = true;
        int i = 0;
        while ((i < limiteCheck) && sempreDiversi) {
            if (a[i].equals(b[i]))
                sempreDiversi = false;
            i++;
        }
        return sempreDiversi;
    }

    /**
    deve prendere come parametro due array di elementi di tipo stringa
    e restituire true se i due array non hanno mai stringhe uguali in
    posizione uguale, false altrimenti. Si noti che gli array potrebbero
    avere dimensione diversa, in questo caso verificare solo le
    posizioni in comune.
    Questa e` un'alternativa un poco meno efficiente della precedente
    @param a primo array di stringhe, assumiano che l'array non e`
    e tutti gli elementi sono inizializzati correttamente
    @param b primo array di stringhe, assumiano che l'array non e`
    e tutti gli elementi sono inizializzati correttamente
    @return true o false secondo specifica
    */
    public static boolean sempreDiversiIbis(String[] a, String[] b) {
        boolean sempreDiversi = true;
        int i = 0;
        while ((i < a.length) && (i < b.length) && sempreDiversi) {
            if (a[i].equals(b[i]))
                sempreDiversi = false;
            i++;
        }
        return sempreDiversi;
    }

    /**
    deve prendere come parametro due array di elementi di tipo stringa
    e restituire true se i due array non hanno mai stringhe uguali in
    posizione uguale, false altrimenti. Si noti che gli array potrebbero
    avere dimensione diversa, in questo caso verificare solo le
    posizioni in comune.
    Questo metodo e` una soluzione alternativa al precedente sempreDiversiI 
    @param a primo array di stringhe, assumiano che l'array non e`
    e tutti gli elementi sono inizializzati correttamente
    @param b primo array di stringhe, assumiano che l'array non e`
    e tutti gli elementi sono inizializzati correttamente
    @return true o false secondo specifica
    */
    public static boolean sempreDiversiII(String[] a, String[] b) {
        int limiteCheck;
        if (a.length > b.length)
            limiteCheck = b.length;
        else
            limiteCheck = a.length;
        int i = 0;
        while (i < limiteCheck) {
            if (a[i].equals(b[i]))
                return false;
            i++;
        }
        return true;
    }


    /**
        Risultato atteso dal main:

        Inverso? true
        Inverso? true
        Sempre diversi? false
        Sempre diversi? false
        Sempre diversi? false
        Inverso? false
        Inverso? false
        Sempre diversi? true
        Sempre diversi? true
        Sempre diversi? true

    */
    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";
        String[] b = new String[5];
        b[4] = "matteo";
        b[3] = "baldoni";
        b[2] = "esame";
        b[1] = "programmazione";
        b[0] = "laboratorio";
        System.out.println("Inverso? " + inversoI(a, b));
        System.out.println("Inverso? " + inversoII(a, b));
        System.out.println("Sempre diversi? " + sempreDiversiI(a, b));
        System.out.println("Sempre diversi? " + sempreDiversiIbis(a, b));
        System.out.println("Sempre diversi? " + sempreDiversiII(a, b));
        b[2] = "voto";
        System.out.println("Inverso? " + inversoI(a, b));
        System.out.println("Inverso? " + inversoII(a, b));
        System.out.println("Sempre diversi? " + sempreDiversiI(a, b));
        System.out.println("Sempre diversi? " + sempreDiversiIbis(a, b));
        System.out.println("Sempre diversi? " + sempreDiversiII(a, b));
    }

}