package esami;

public class dicembre2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a={1, 4, 3, 1, 4, 4, 1, 3, 5, 10};
		int[] b={2, 7, 9, 0};
		stampaArray(a);
		// int [] c = rimuoviDuplicati(a);
		//sort(c); prossima volta
		// stampaArray(c);
		System.out.println(listaPosizioniUguali(a,b));
		double[][] m1= { {1.0, 1.5, 0.3},
				           {0.5, 3.0, 1.0} };
		double[][] m2={ {1.5, 2.5, 0.0},
				          {1.5, 4.0, 2.0} };
		
			/*     restituisce { {2.5, 4.0, 0.3},
			 *                  {2.0, 7.0, 3.0} }  
		     */
		System.out.println(posizioniUguali(a,b));
		System.out.println(conteggio(a,b));
		// stampaMatrice2 (m1);
		//stampaMatrice (m2);
		//double[][] somma = sommaMatrici(m1,m2);
		//stampaMatrice (somma);
	}
	
	/*
	 * scrivere un metodo che dati due array a e b di 
	 * interi, restituisce il numero di elementi dell'array
	 * a che sono presenti anche nell'array b
	 * es: se a={1, 4, 3, 1, 5, 10} e b={3, 5, 1, 3}
	 *     il metodo deve restituire 4
	 */
	static int conteggio(int[] a, int[]b) {
		int conto=0;
		for (int i=0; i<a.length; i++)
		{for (int j=0; j <b.length; j++)
			if (a[i]==b[j]) {conto ++; j=b.length;}  //si puņ usare anche break; 
		}
		return conto;
	}
	
	/*
	 * scrivere un metodo posizioniUguali che, presi come 
	 * parametri 2 array a e b di int non necessariamente 
	 * della stessa lunghezza, restituisce quante 
	 * sono le posizioni che contengono in a e b lo stesso
	 * valore.
	 * es: se a={1, 5, 2, 8} e b = {9, 5, 9, 8, 10, 20}
	 *     il metodo restituisce 2
	 */
	static int posizioniUguali (int[]a, int[]b) {
		int conto=0;
		for (int i =0; i< a.length && i< b.length; i++)
			if (a[i]==b[i]) conto ++;
		return conto;
	}
	
	/*
	 * scrivere un metodo listaPosizioniUguali che, presi come 
	 * parametri 2 array a e b di int, restituisce un
	 * nuovo array contenente tutte e sole le posizioni i
	 * per cui vale che a[i]=b[i].
	 * es: se a={1, 5, 2, 8} e b = {9, 5, 9, 8, 10, 20}
	 *     il metodo restituisce {1,3}
	 */
	static int[] listaPosizioniUguali(int[]a, int[]b) {
		/*
		 * 1) contare quanto deve essere lungo l'array 
		 *    da creare GIA' FATTO
		 */
		int n=posizioniUguali (a, b);
		//2 creazione
		int[] ris= new int[n];
		//3 riempimento
		int indice=0;
		for (int i=0; i <a.length && i < b.length; i++)
			{if (a[i]==b[i]) {ris[indice]=i; indice++;}}
		return ris;
	}
	
	/*  scrivere un metodo che stampa un array nella forma seguente
	 * { 2, 5, 7, 3 }
	 * sia per array di interi che di double
	 * */
	static void stampaArray (int[]a) {
	}
	
   static void stampaArray (double[]a) {
	}
   /*  scrivere un metodo che stampa un array nella forma seguente
	 * { 2, 5, 7, 3 }
	 * che non va a capo dopo }. Si usa per il metodo stampaMatrice
	 * */
   static void stampaArrayNoCapo (double[]a) {
	}
	/*  scrivere un metodo che stampa le matrici nella forma seguente
	 * { { 2.0, 5.7, 3.2 },
	 * { 3.4, 5.2, 6.4 } }
	 * 
	 */
   
   
	static void stampaMatrice (double[][] a) {
	}
	
	/* usa stampaArray modificato non andando a capo dopo }*/
	static void stampaMatrice2 (double[][] a) {
		
	}
	/*
	 * scrivere un metodo rimuoviDuplicati che,
	 * preso come parametro un array a di int,
	 * restituisce un nuovo array che 
	 * contiene tutti e soli
	 * gli elementi di a senza ripetizioni (nello stesso
	 * ordine in cui sono presenti in a)
	 * es: se a={1, 4, 3, 1, 6, 3, 1, 7}
	 *     restituisce {1, 4, 3, 6, 7}
	 */
	/*
	 * static int[] rimuoviDuplicati (int[]a) {
		//1) conteggio della lunghezza dell'array finale
		
		//2) creazione dell'array ris
		
		int[]ris;
		
		//3) riempimento dell'array ris
		
		return ris;
	}
*/	
	/*
	 * scrivere un metodo sort che, preso come parametro
	 * un array di int, lo ordina in modo non decrescente
	 * es: se a ={6, 3, 8, 2, 10, 20, 3}
	 *     {2, 3, 8, 6, 10, 20, 3}
	 *     il metodo lo modifica in 
	 *     {2, 3, 3, 6, 8, 10, 20}
	 */
	 //static void sort (int[] a) {
		
	// }
	
	/*scrivere un metodo sommaMatrici che presi 2 array 
	 * bidimensionali di double a e b 
	 * (si puņ assumere che siano
	 * rettangolari ed abbiano le stesse dimensioni)
	 * crea e restituisce un nuovo array bidimensionale
	 * di double corrispondente alla matrice a+b
	 * es: se a= { {1.0, 1.5, 0.3},
	 *             {0.5, 3.0, 1.0} }
	 *      e b ={ {1.5, 2.5, 0.0},
	 *             {1.5, 4.0, 2.0} }
	 *     restituisce { {2.5, 4.0, 0.3},
	 *                  {2.0, 7.0, 3.0} }      
	 */
/*
static double[][] sommaMatrici 
	                  (double[][]a, double[][]b){
		double [][] ris;
		return ris;
}
*/

}