// Scrivere un programma Java che legga da input una sequenza di 
// cifre intere (quindi comprese tra 0 e 9) e le memorizzi in un array; 
// la dimensione dell'array (e quindi quanti elementi sono contenuti 
// nella sequenza) deve essere richiesta preventivamente all'utente 
// (quindi: l'utente immettera' un numero - sia esso k - e il programma 
// leggera' k interi da input, memorizzandoli in un array di dimensione 
// k). Quindi, il programma deve stampare su standard output prima
// la somma di tutti gli elementi (cifre) dell'array, e poi le occorrenze 
// di ciascuna cifra nella sequenza. 
// ESEMPIO: se la sequenza prevedesse 5 cifre (su richiesta dell'utente), 
// e fosse la seguente:
// 	  6 5 2 1 1 
// il programma dovrebbe stampare in output prima che la somma degli 
// elementi e' 15, e poi, riguardo alle occorrenze, che la cifra '0' 
// compare zero volte, la cifra '1' compare 2 volte, la cifra '2' 
// compare una volta, e cosi' via fino alla cifra '9'.

import java.util.*;

public class OccorrenzeInArray {

	public static Scanner input = new Scanner(System.in);

	public static void main(String[] args) {
		System.out.print("Quante cifre si intende inserire? ");
		int nelems = input.nextInt();
		int c[] = new int [nelems];
		
		System.out.println("Inserire le cifre, una per volta (solo cifre tra ZERO e NOVE) ");
		for (int i = 0; i < c.length; i++)
			c[i] = input.nextInt();
		
		for (int i = 0; i < c.length; i++)
			System.out.println("c["+i+"] = " + c[i]);
		
		int somma = 0;
		for (int i = 0; i < c.length; i++)
			somma += c[i];
		System.out.println("La somma degli elementi dell'array e' " + somma);
		
	    int frequenze[] = new int[10];
	    for (int i = 0; i < 10; i++)
	    	frequenze[i]=0;
	    	
	    for (int i = 0; i < c.length; i++)
			if ( c[i] >= 0 && c[i] <= 9)
				frequenze[c[i]]++;
		   
	    System.out.println("Le frequenze sono: ");
	    for(int i=0; i<10; i++)
	        System.out.println(" Cifra " + i + " : " + frequenze[i] + " occorrenze.");
	}      
}



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////



// Scrivere un programma Java che, sfruttando opportuni metodi statici,
// memorizzi un array di interi ed esegua una serie di operazioni. 
// Il programma deve preliminarmente chiedere all'utente quanti numeri 
// intende inserire; quindi leggera' da input questi interi e li 
// memorizzera' in un array opportunamente dimensionato.
// Le operazioni da effettuare sono le seguenti: 
//  - verificare se l'array e' palindromo;
//  - verificare se l'array e' crescente;
//  - calcolare il massimo nel vettore.
// Ciascuna di queste verifiche deve essere demandata ad un opportuno 
// metodo statico, in versione sia ITERATIVA che RICORSIVA. In totale, 
// quindi, si dovranno realizzare ALMENO 7 metodi: 
//  - uno che legga un array
//  - due per la verifica su array palindromo, uno iterativo ed uno 
//    ricorsivo
//  - due per la verifica su array crescente, uno iterativo ed uno
//    ricorsivo
//  - due per la ricerca del massimo in un array, uno iterativo 
//    ed uno ricorsivo.

import java.util.*;

public class VerificheSuArray {
	
	public static Scanner input = new Scanner(System.in);

	public static void leggiArray(int a[]){
		System.out.println("Inserire " + a.length + " numeri interi, elementi di un array");
		for (int i=0; i < a.length; i++)
			a[i] = input.nextInt();
	}
	
	public static boolean palindromoIterativo (int a[]){
		for (int i = 0; i < a.length/2; i++)
			if (a[i] != a[a.length-1-i])
				return false;
		return true;
	}
	
	public static boolean palindromoRicorsivo (int a[], int inf, int sup) {
		if (inf >= sup)
			return true;
		if (a[inf] != a[sup])
			return false;
		return palindromoRicorsivo(a,inf+1,sup-1);
	}
	
	public static boolean arrayCrescenteIterativo(int a[]) {
		for (int i=0; i < a.length - 1; i++)
			if(a[i] > a[i+1])
				return false;
		return true;
	}
	
	public static boolean arrayCrescenteRicorsivo(int a[], int pos) {
		if (pos >= a.length - 1)
			return true;
		if (a[pos] > a[pos+1])
			return false;
		return arrayCrescenteRicorsivo(a,pos+1);
	}
	
	public static int maxInArrayIterativo ( int a[] ) {
		int max = a[0];
		for (int i = 1; i < a.length; i++)
			if (a[i] > max)
				max = a[i];
		return max;
	}
	
	public static int maxInArrayRicorsivoLineare ( int a[], int pos, int maxCorrente ) {
		if (pos >= a.length) 
			return maxCorrente;
		if (a[pos] > maxCorrente)
				maxCorrente = a[pos];
		return maxInArrayRicorsivoLineare ( a, pos+1, maxCorrente );
	}
	
	public static int max ( int x, int y ) {
		if ( x > y )
			return x;
		return y;
	}
	
	public static int maxInArrayRicorsivoMetaAllaVolta ( int a[], int inizio, int fine ) {
		if ( inizio == fine )
			return a[inizio];
		if ( fine == inizio + 1 )
			return max( a[inizio], a [fine] );
			
		int medio = (fine + inizio) / 2;
		return ( max(maxInArrayRicorsivoMetaAllaVolta(a, inizio, medio), maxInArrayRicorsivoMetaAllaVolta(a, medio+1, fine ) ) ); 
	}
	
	
	public static void main(String[] args) {
		System.out.println(" Quanti elementi conterra' l'array? ");
		
		int v[] = new int[input.nextInt()];
		leggiArray(v);
	
		if (palindromoIterativo(v))
			System.out.println(" Verifica iterativa : l'array e' palindromo! ");
		else
			System.out.println(" Verifica iterativa : l'array NON e' palindromo... ");

		if (palindromoRicorsivo(v, 0, v.length-1))
			System.out.println(" Verifica ricorsiva : l'array e' palindromo! ");
		else
			System.out.println(" Verifica ricorsiva : l'array NON e' palindromo... ");
		
		if (arrayCrescenteIterativo(v))
			System.out.println(" Verifica iterativa : l'array e' crescente! ");
		else
			System.out.println(" Verifica iterativa : l'array NON e' crescente... ");

		if (arrayCrescenteRicorsivo(v,0))
			System.out.println(" Verifica ricorsiva : l'array e' crescente! ");
		else
			System.out.println(" Verifica ricorsiva : l'array NON e' crescente... ");
		
		System.out.println(" Calcolo iterativo                   : il max nell'array e' : " 
							 + maxInArrayIterativo(v) );
		System.out.println(" Calcolo ricorsivo lineare           : il max nell'array e' : " 
							 + maxInArrayRicorsivoLineare(v, 0, v[0]) );
		System.out.println(" Calcolo iterativo meta' alla volta  : il max nell'array e' : " 
							 + maxInArrayRicorsivoMetaAllaVolta(v, 0, v.length-1) );
	}
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


// Scrivere un programma java che, letto da input un numero 
// intero, determini quale e' la cifra piu' grande che esso 
// contiene, tramite un metodo RICORSIVO.
// Il programma poi, ancora tramite un metodo ricorsivo, 
// stampi i fattori primi che compongono il numero letto 
// in precedenza. 

import java.util.*;

public class Ricorsione01 {

	public static Scanner input = new Scanner(System.in);

	public static int maxCifra (int n, int maxCorrente) {
		if ( n / 10 <= 0 )
			if ( n > maxCorrente )
				return n;
			else 
				return maxCorrente;
		else {
			if ( (n%10) > maxCorrente )
				maxCorrente = n%10;
			
			return maxCifra ( (int)(n/10), maxCorrente );
		}
	}

	public static void scomponiInFattoriPrimi (int n, int fattore) {
		if ( fattore <= n ) {		
			if ( n % fattore == 0 ) { 
				System.out.print( fattore + " ");
				scomponiInFattoriPrimi (n/fattore, fattore);
			}
			else
				scomponiInFattoriPrimi (n, fattore+1);
		}
	}
	
	public static void main(String[] args) {

		System.out.println("Inserisci un numero intero, ti diro' quale e' la cifra piu' grande che contiene :  ");
		int x = input.nextInt();
		int cifraMax = maxCifra(x,0);
		System.out.println("  -- la cifra piu' grande e' ... : " + cifraMax);
		System.out.println("I fattori primi che compongono " + x + " sono : ");
		scomponiInFattoriPrimi(x,2);
		System.out.println();
	}
}