1 // Scrivere un programma Java che legga da input una sequenza di 
   2 // cifre intere (quindi comprese tra 0 e 9) e le memorizzi in un array; 
   3 // la dimensione dell'array (e quindi quanti elementi sono contenuti 
   4 // nella sequenza) deve essere richiesta preventivamente all'utente 
   5 // (quindi: l'utente immettera' un numero - sia esso k - e il programma 
   6 // leggera' k interi da input, memorizzandoli in un array di dimensione 
   7 // k). Quindi, il programma deve stampare su standard output prima
   8 // la somma di tutti gli elementi (cifre) dell'array, e poi le occorrenze 
   9 // di ciascuna cifra nella sequenza. 
  10 // ESEMPIO: se la sequenza prevedesse 5 cifre (su richiesta dell'utente), 
  11 // e fosse la seguente:
  12 // 	  6 5 2 1 1 
  13 // il programma dovrebbe stampare in output prima che la somma degli 
  14 // elementi e' 15, e poi, riguardo alle occorrenze, che la cifra '0' 
  15 // compare zero volte, la cifra '1' compare 2 volte, la cifra '2' 
  16 // compare una volta, e cosi' via fino alla cifra '9'.
  17 
  18 import java.util.*;
  19 
  20 public class OccorrenzeInArray {
  21 
  22 	public static Scanner input = new Scanner(System.in);
  23 
  24 	public static void main(String[] args) {
  25 		System.out.print("Quante cifre si intende inserire? ");
  26 		int nelems = input.nextInt();
  27 		int c[] = new int [nelems];
  28 		
  29 		System.out.println("Inserire le cifre, una per volta (solo cifre tra ZERO e NOVE) ");
  30 		for (int i = 0; i < c.length; i++)
  31 			c[i] = input.nextInt();
  32 		
  33 		for (int i = 0; i < c.length; i++)
  34 			System.out.println("c["+i+"] = " + c[i]);
  35 		
  36 		int somma = 0;
  37 		for (int i = 0; i < c.length; i++)
  38 			somma += c[i];
  39 		System.out.println("La somma degli elementi dell'array e' " + somma);
  40 		
  41 	    int frequenze[] = new int[10];
  42 	    for (int i = 0; i < 10; i++)
  43 	    	frequenze[i]=0;
  44 	    	
  45 	    for (int i = 0; i < c.length; i++)
  46 			if ( c[i] >= 0 && c[i] <= 9)
  47 				frequenze[c[i]]++;
  48 		   
  49 	    System.out.println("Le frequenze sono: ");
  50 	    for(int i=0; i<10; i++)
  51 	        System.out.println(" Cifra " + i + " : " + frequenze[i] + " occorrenze.");
  52 	}      
  53 }
  54 
  55 
  56 
  57 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  58 
  59 
  60 
  61 // Scrivere un programma Java che, sfruttando opportuni metodi statici,
  62 // memorizzi un array di interi ed esegua una serie di operazioni. 
  63 // Il programma deve preliminarmente chiedere all'utente quanti numeri 
  64 // intende inserire; quindi leggera' da input questi interi e li 
  65 // memorizzera' in un array opportunamente dimensionato.
  66 // Le operazioni da effettuare sono le seguenti: 
  67 //  - verificare se l'array e' palindromo;
  68 //  - verificare se l'array e' crescente;
  69 //  - calcolare il massimo nel vettore.
  70 // Ciascuna di queste verifiche deve essere demandata ad un opportuno 
  71 // metodo statico, in versione sia ITERATIVA che RICORSIVA. In totale, 
  72 // quindi, si dovranno realizzare ALMENO 7 metodi: 
  73 //  - uno che legga un array
  74 //  - due per la verifica su array palindromo, uno iterativo ed uno 
  75 //    ricorsivo
  76 //  - due per la verifica su array crescente, uno iterativo ed uno
  77 //    ricorsivo
  78 //  - due per la ricerca del massimo in un array, uno iterativo 
  79 //    ed uno ricorsivo.
  80 
  81 import java.util.*;
  82 
  83 public class VerificheSuArray {
  84 	
  85 	public static Scanner input = new Scanner(System.in);
  86 
  87 	public static void leggiArray(int a[]){
  88 		System.out.println("Inserire " + a.length + " numeri interi, elementi di un array");
  89 		for (int i=0; i < a.length; i++)
  90 			a[i] = input.nextInt();
  91 	}
  92 	
  93 	public static boolean palindromoIterativo (int a[]){
  94 		for (int i = 0; i < a.length/2; i++)
  95 			if (a[i] != a[a.length-1-i])
  96 				return false;
  97 		return true;
  98 	}
  99 	
 100 	public static boolean palindromoRicorsivo (int a[], int inf, int sup) {
 101 		if (inf >= sup)
 102 			return true;
 103 		if (a[inf] != a[sup])
 104 			return false;
 105 		return palindromoRicorsivo(a,inf+1,sup-1);
 106 	}
 107 	
 108 	public static boolean arrayCrescenteIterativo(int a[]) {
 109 		for (int i=0; i < a.length - 1; i++)
 110 			if(a[i] > a[i+1])
 111 				return false;
 112 		return true;
 113 	}
 114 	
 115 	public static boolean arrayCrescenteRicorsivo(int a[], int pos) {
 116 		if (pos >= a.length - 1)
 117 			return true;
 118 		if (a[pos] > a[pos+1])
 119 			return false;
 120 		return arrayCrescenteRicorsivo(a,pos+1);
 121 	}
 122 	
 123 	public static int maxInArrayIterativo ( int a[] ) {
 124 		int max = a[0];
 125 		for (int i = 1; i < a.length; i++)
 126 			if (a[i] > max)
 127 				max = a[i];
 128 		return max;
 129 	}
 130 	
 131 	public static int maxInArrayRicorsivoLineare ( int a[], int pos, int maxCorrente ) {
 132 		if (pos >= a.length) 
 133 			return maxCorrente;
 134 		if (a[pos] > maxCorrente)
 135 				maxCorrente = a[pos];
 136 		return maxInArrayRicorsivoLineare ( a, pos+1, maxCorrente );
 137 	}
 138 	
 139 	public static int max ( int x, int y ) {
 140 		if ( x > y )
 141 			return x;
 142 		return y;
 143 	}
 144 	
 145 	public static int maxInArrayRicorsivoMetaAllaVolta ( int a[], int inizio, int fine ) {
 146 		if ( inizio == fine )
 147 			return a[inizio];
 148 		if ( fine == inizio + 1 )
 149 			return max( a[inizio], a [fine] );
 150 			
 151 		int medio = (fine + inizio) / 2;
 152 		return ( max(maxInArrayRicorsivoMetaAllaVolta(a, inizio, medio), maxInArrayRicorsivoMetaAllaVolta(a, medio+1, fine ) ) ); 
 153 	}
 154 	
 155 	
 156 	public static void main(String[] args) {
 157 		System.out.println(" Quanti elementi conterra' l'array? ");
 158 		
 159 		int v[] = new int[input.nextInt()];
 160 		leggiArray(v);
 161 	
 162 		if (palindromoIterativo(v))
 163 			System.out.println(" Verifica iterativa : l'array e' palindromo! ");
 164 		else
 165 			System.out.println(" Verifica iterativa : l'array NON e' palindromo... ");
 166 
 167 		if (palindromoRicorsivo(v, 0, v.length-1))
 168 			System.out.println(" Verifica ricorsiva : l'array e' palindromo! ");
 169 		else
 170 			System.out.println(" Verifica ricorsiva : l'array NON e' palindromo... ");
 171 		
 172 		if (arrayCrescenteIterativo(v))
 173 			System.out.println(" Verifica iterativa : l'array e' crescente! ");
 174 		else
 175 			System.out.println(" Verifica iterativa : l'array NON e' crescente... ");
 176 
 177 		if (arrayCrescenteRicorsivo(v,0))
 178 			System.out.println(" Verifica ricorsiva : l'array e' crescente! ");
 179 		else
 180 			System.out.println(" Verifica ricorsiva : l'array NON e' crescente... ");
 181 		
 182 		System.out.println(" Calcolo iterativo                   : il max nell'array e' : " 
 183 							 + maxInArrayIterativo(v) );
 184 		System.out.println(" Calcolo ricorsivo lineare           : il max nell'array e' : " 
 185 							 + maxInArrayRicorsivoLineare(v, 0, v[0]) );
 186 		System.out.println(" Calcolo iterativo meta' alla volta  : il max nell'array e' : " 
 187 							 + maxInArrayRicorsivoMetaAllaVolta(v, 0, v.length-1) );
 188 	}
 189 }
 190 
 191 
 192 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 193 
 194 
 195 // Scrivere un programma java che, letto da input un numero 
 196 // intero, determini quale e' la cifra piu' grande che esso 
 197 // contiene, tramite un metodo RICORSIVO.
 198 // Il programma poi, ancora tramite un metodo ricorsivo, 
 199 // stampi i fattori primi che compongono il numero letto 
 200 // in precedenza. 
 201 
 202 import java.util.*;
 203 
 204 public class Ricorsione01 {
 205 
 206 	public static Scanner input = new Scanner(System.in);
 207 
 208 	public static int maxCifra (int n, int maxCorrente) {
 209 		if ( n / 10 <= 0 )
 210 			if ( n > maxCorrente )
 211 				return n;
 212 			else 
 213 				return maxCorrente;
 214 		else {
 215 			if ( (n%10) > maxCorrente )
 216 				maxCorrente = n%10;
 217 			
 218 			return maxCifra ( (int)(n/10), maxCorrente );
 219 		}
 220 	}
 221 
 222 	public static void scomponiInFattoriPrimi (int n, int fattore) {
 223 		if ( fattore <= n ) {		
 224 			if ( n % fattore == 0 ) { 
 225 				System.out.print( fattore + " ");
 226 				scomponiInFattoriPrimi (n/fattore, fattore);
 227 			}
 228 			else
 229 				scomponiInFattoriPrimi (n, fattore+1);
 230 		}
 231 	}
 232 	
 233 	public static void main(String[] args) {
 234 
 235 		System.out.println("Inserisci un numero intero, ti diro' quale e' la cifra piu' grande che contiene :  ");
 236 		int x = input.nextInt();
 237 		int cifraMax = maxCifra(x,0);
 238 		System.out.println("  -- la cifra piu' grande e' ... : " + cifraMax);
 239 		System.out.println("I fattori primi che compongono " + x + " sono : ");
 240 		scomponiInFattoriPrimi(x,2);
 241 		System.out.println();
 242 	}
 243 }