/*
 ********
 * visualizzaVettore: deve visualizzare, usando System.out.print
 * e System.out.println, 
 * una riga contenente un messaggio, seguita dagli elementi
 * dell'array separati da due spazi.
 * L'array e il messaggio vengono passati come parametri.
 * Dopo aver visualizzato l'ultimo elemento e' necessario andare a capo.
 * Per esempio:
 
Ecco il vettore a
1  42  0  344  5  6
 *
 ********
 * leggiIntero: restituisce un intero letto da tastiera
 * non ha arametri.
 *
 ********
 * cerca(a, valoreDaCercare): restituisce la prima posizione dell'array in cui compare
 * un certo valore. Se il valore non e' presente restituisce -1.
 * parametri: l'array e il valore da cercare.
 *
 ********
 * prodottoScalare: restituisce (NON STAMPA) il prodotto scalare (int) dei due
 * array passati come parametri.
 * Nel caso dei vettori a e b dell'esempio, il risultato deve essere 9469
 * Si assume che i due array abbiano la stessa lunghezza.
 *
 ********
 * contaZeri restituisce il numero di elementi pari a zero trovati
 * nell'array parametro
 *
 ********
 * contaMaggiori restituisce il numero di elementi nell'array
 * primo parametro che sono maggiori del valore del secondo parametro
 *
 ********
 * compatta: riceve come parametro un array di interi, e restituisce il
 * riferimento a un nuovo array.
 * Il metodo deve creare un nuovo array di dimensione pari al numero di
 * elementi del primo array diversi da zero (per contare tali elementi
 * si puo' usare il metodo contaZeri),
 * e inserire nel nuovo array tali elementi. Gli elementi devono
 * essere copiati conservando l'ordine in cui compaiono nel primo array.
 * Nel caso dell'array b inizializzato nel codice, l'array compattato
 * conterra' gli elementi 5 18 25 18
 *
 ********
 */

/** Questa classe contiene una collezione di metodi static che lavorano su array monodimensionali.
Può essere estesa arricchendola con altri metodi, anche su array bidimensionali
*/
import java.util.Scanner;

public class MieiMetodi {

/** Visualizza gli elementi di un array di interi.
    Gli elementi vengono stampati su una riga, separati da due spazi.
    Si va a capo dopo l'ultimo elemento.
    Prima degli elementi viene stampata una riga contenente la stringa di testo
    passata come secondo parametro
    
    @param x l'array da stampare
    @param messaggio la stringa di testo che deve precedere la stampa degli elementi
*/
	public static void visualizzaVettore(int[] x, String messaggio) {
		System.out.println(messaggio);
		for(int i = 0; i < x.length; i++)
			System.out.print(x[i] + "  ");
		System.out.println();
		System.out.println();
	}


/** Legge un intero da tastiera.
    
    @return l'intero letto da tastiera
*/
	public static int leggiIntero() {
		Scanner lett = new Scanner(System.in);
		System.out.print("Digita un intero: ");
		int n = lett.nextInt();
		return n;
	}


/** Cerca un valore in un array di int.
    
    @param v l'array nel quale cercare l'elemento
    @param x il valore da cercare
    @return la posizione della prima occorrenza del valore cercato nell'array.
            Restisuisce -1 se il valore non e' presente nell'array
*/
	public static int cerca(int[] v, int x) {
		int pos = 0;
		for(int i = 0; i < v.length; i++)
			if(v[i]==x)
				return i;
		return -1; // raggiunge questa istruzione solo se non trova l'elemento
	}


/** Calcola il prodotto scalare dei vettori rappresentati da due array di int.
    Il prodotto scalare &egrave; la somma dei prodotti degli elementi omologhi.
    
    @param x il primo array
    @param y il secondo array
    @return il prodotto salare di x e y
*/
	public static int prodottoScalare(int[] x, int[] y)	{
		int p = 0;
		for(int i = 0; i < x.length; i++)
			p += x[i] * y[i];
		return p;
	}
	
	public static int contaZeri(int[] x)	{
		int conta = 0;
		for(int i = 0; i < x.length; i++)
			if(x[i] == 0)
				conta++;
		return conta;
	}
	
	public static int contaMaggiori(int[] x, int t)	{
		int conta = 0;
		for(int i = 0; i < x.length; i++)
			if(x[i] > t)
				conta++;
		return conta;
	}

	public static boolean crescente(int[] x)	{
		for(int i = 0; i < x.length-1; i++)
			if(x[i] >= x[i+1])
				return false;
		return true;
	}
	
}