1 // Progettare due metodi statici in un programma Java, siano i loro nomi "raddoppiaArrayIterativo" e 
   2 // "raddoppiaArrayRicorsivo". Entrambi devono ricevere due array di interi, siano "a" e "b". I metodi 
   3 // presuppongono che i due array  siano stati gia' creati nel main, e che "a" sia stato anche 
   4 // inizializzato attraverso una lettura da input. Entrambi i metodi devono semplicemente 
   5 // riempire "b" con gli elementi di "a" moltiplicati per 2; come suggeriscono i nomi, il primo metodo 
   6 // deve essere iterativo, mentre il secondo ricorsivo.
   7 
   8 // *** ESEMPIO: se l'arrai "a" fosse 
   9 //     3  5  6  3  2  6  4  3  5  2
  10 // allora l'array "b" dovrebbe essere creato come
  11 //    6 10 12  6  4  12 8  6 10  4.
  12 
  13 import java.util.*;
  14 
  15 public class RaddoppiaArray {
  16 	
  17     public static Scanner input = new Scanner(System.in); 
  18 
  19     public static void leggiArray(int a[]){
  20     	System.out.println("Inserire " + a.length + " numeri interi, elementi di un array");
  21     	for (int i=0; i < a.length; i++)
  22     		a[i] = input.nextInt();
  23     }
  24 
  25     public static void raddoppiaIterativo (int a[], int b[]){
  26     	for (int i = 0; i < a.length; i++)
  27     		b[i] = a[i]*2;
  28     }
  29     
  30     public static void raddoppiaRicorsivo (int a[], int b[], int pos){
  31     	if (pos < a.length){
  32     		b[pos] = a[pos]*2;
  33     		raddoppiaRicorsivo(a, b, pos+1);
  34     	}
  35     }
  36     
  37     public static void stampaArray(int a[]){
  38     	for (int i=0; i < a.length; i++)
  39     		System.out.println(a[i]);
  40     }
  41 
  42 	public static void main(String[] args) {
  43         System.out.println("Quanti elementi conterra' l'array? ");
  44 
  45         int a[] = new int[input.nextInt()];
  46         leggiArray(a);
  47         
  48         int b[] = new int[a.length];
  49         
  50         raddoppiaIterativo(a, b);
  51         System.out.println("Array raddoppiato (iterativamente): ");
  52         stampaArray(b);
  53         
  54         raddoppiaRicorsivo(a, b, 0);
  55         System.out.println("Array raddoppiato (ricorsivamente): ");
  56         stampaArray(b);
  57 	}
  58 
  59 }
  60 
  61 
  62 /////////////////////////////////////////////////////////////////////////////////7
  63 
  64 
  65 // Scrivere un programma Java che preveda un metodo statico chiamato "minimiLocali".
  66 // Questo metodo deve ricevere un array di interi ed uno di booleani. Siano questi
  67 // array chiamati "v" e "minimo", 
  68 // e siano le loro lunghezze "v.length" e "minimo.length". Il metodo presuppone che i due array 
  69 // siano stati gia' creati e inizializzati nel main; "v" deve essere letto da input, "minimo",
  70 // invece, deve essere inizializzato con elementi tutti pari a "false".
  71 // Gli array devono essere tali che si abbia "v.length==minimo.length". 
  72 // Il metodo "minimiLocali" deve semplicemente far si' che, dopo la sua invocazione, l'array "minimo" 
  73 // contenga "true" in una posizione "i" se e solo se nella posizione "i" dell'array "v" e' presente 
  74 // un minimo locale, cioe' un numero minore sia del suo precedente che del suo successivo.
  75 
  76 // *** ESEMPIO: se l'array "v" fosse 
  77 
  78 //       ---------------
  79 //  v   |1|3|6|2|6|7|1|8| 
  80 //       ---------------
  81 //       0 1 2 3 4 5 6 7
  82 
  83 // allora l'array "minimo" dovrebbe contenere "true" solo nelle posizioni "3" e "6", e "false" in 
  84 // tutte le altre: infatti 2 e 1 sono minimi locali, e si trovano rispettivamente nelle posizioni "3" e "6".
  85 
  86 import java.util.*;
  87 
  88 public class MinimiLocali {
  89 
  90 	public static Scanner input = new Scanner(System.in); 
  91 
  92     public static void leggiArray(int a[]){
  93     	System.out.println("Inserire " + a.length + " numeri interi, elementi di un array");
  94     	for (int i=0; i < a.length; i++)
  95     		a[i] = input.nextInt();
  96     }
  97 
  98     public static void minimiLocali(int a[], boolean b[]){
  99     	for (int i=1; i < a.length-1; i++)
 100     		if (a[i] < a[i-1] && a[i] < a[i+1])
 101     			b[i] = true;
 102     }
 103 
 104 	public static void main(String[] args) {
 105         System.out.println("Quanti elementi conterra' l'array? ");
 106 
 107         int v[] = new int[input.nextInt()];
 108         leggiArray(v);
 109         
 110         boolean minimo[] = new boolean[v.length];
 111     	for (int i=0; i < minimo.length; i++)
 112     		minimo[i] = false;
 113         
 114     	minimiLocali(v, minimo);
 115     	
 116         System.out.println("Sono minimi locali i seguenti elementi: ");
 117     	for (int i=0; i < minimo.length; i++)
 118     		if (minimo[i])
 119     			System.out.println(v[i] + " in posizione " + i + " dell'array");  	
 120 	}
 121 
 122 }
 123 
 124 
 125 
 126 ///////////////////////////////////////////////////////////////////////////////////////////////
 127 
 128 
 129 /*
 130 Esercizio 3
 131 ---
 132 Una piccola compagnia aerea ha appena acquistato un computer da dedicare
 133 al sistema di prenotazione
 134 automatica dei voli. La compagnia vi ha chiesto di programmare il sistema.
 135 Il vostro compito è 
 136 scrivere un programma che assegna i posti di ogni volo dell'unico aereo
 137 posseduto dalla compagnia 
 138 (10 posti in tutto).
 139 Il vostro programma dovrebbe visualizzare questo menù di opzioni:
 140 
 141     Digitare 1 per fumatori o 2 per non fumatori:
 142 
 143 Se la persona digita 1, il programma le assegna un posto nel reparto
 144 fumatori (posti 1-5). 
 145 Se invece digita 2, il posto si troverà nel reparto non fumatori (posti
 146 6-10). Il programma deve 
 147 visualizzare una carta di imbarco che indica il numero del posto della
 148 persona e se si trova nel
 149 reparto non fumatori o fumatori, del tipo
 150 
 151     Reparto fumatori, posto 3   
 152 
 153 Utilizzate un array per rappresentare i posti dell'aereo. Inizializzate
 154 tutti gli elementi 
 155 dell'array a 0, per indicare che all'inizio tutti i posti sono vuoti. Man
 156 mano che vengono 
 157 assegnati, impostate i posti occupati a 1. Il programma, ovviamente, non
 158 deve riassegnare i posti
 159 già occupati. 
 160 Se il reparto richiesto e' completamente occupato, il programma dovra'
 161 segnalare:
 162 
 163     Reparto completo. Il prossimo volo parte tra 3 ore.
 164 
 165 *** POSSIBILE MODIFICA: Quando il reparto richiesto si è riempito,
 166 chiedere al passeggero se è accettabile 
 167 andare nell'altro reparto. Se il passeggero accetta, gli si assegna un
 168 posto nell'altro reparto (ammesso 
 169 che ci sia un posto disponibile). Se il passeggero rifiuta, o anche se
 170 accetta ma anche l'altro reparto 
 171 è pieno, visualizzate 
 172  
 173    Il prossimo volo parte tra 3 ore.
 174 
 175  */
 176 
 177 
 178 import java.util.Scanner;
 179 
 180 public class PoorAirlines {
 181 
 182     public enum Reparto {FUMATORI, NON_FUMATORI}; 
 183     
 184     public static Reparto leggiReparto(Scanner input) {
 185 	int scelta;
 186 	do{
 187 	    System.out.print("Digitare 1 per fumatori o 2 per non fumatori: ");
 188 	    scelta = input.nextInt();
 189 	}while(scelta != 1 && scelta != 2);
 190 	
 191 	if(scelta == 1)
 192 	    return Reparto.FUMATORI;
 193 	else
 194 	    return Reparto.NON_FUMATORI;
 195     }
 196     
 197     public static String repartoToString(Reparto r) {
 198 	switch (r) {
 199 	case FUMATORI:
 200 	    return "fumatori";
 201 	    
 202 	case NON_FUMATORI:
 203 	    return "non fumatori";
 204 
 205 	default:
 206 	    return "";
 207 	}
 208     }
 209     
 210     public static int trovaPosto(Reparto r, int[] p) {
 211 	int da;
 212 	int a;
 213 	
 214 	// i posti fumatori sono da 1 a 5 
 215 	if(r == Reparto.FUMATORI) {
 216 	    da = 1;
 217 	    a = 5;
 218 	}
 219 	// i non fumatori da 6 a 10
 220 	else {	    
 221 	    da = 6;
 222 	    a = 10;
 223 	}
 224 	
 225 	for(int ris = da; ris <= a; ris++) {
 226 	    // verifica se il posto è libero
 227 	    if(p[ris] == 0)
 228 		return ris;
 229 	}
 230 	
 231 	// se non hai trovato un posto libero
 232 	return -1;
 233     }
 234     
 235     public static Reparto scambiaReparto(Reparto r) {
 236 	if(r == Reparto.FUMATORI)
 237 	    return Reparto.NON_FUMATORI;
 238 	else
 239 	    return Reparto.FUMATORI;
 240     }
 241     
 242     public static void main(String[] args) {
 243 	Scanner input = new Scanner(System.in);
 244 	
 245 	// per comodita` non utilizzeremo l'emento di indice 0 
 246 	int[] posti = new int[11];
 247 	
 248 	// all'inizio tutti i posti sono liberi (ovvero 0)
 249 	for(int i = 1; i < posti.length; i++)
 250 	    posti[i] = 0;
 251 	
 252 	while(true) {
 253 	    System.out.println("\nLa PoorAirlines le da il benvenuto.\n");
 254 	    Reparto rep = leggiReparto(input);
 255 	    int posto = trovaPosto(rep, posti);
 256 	    if(posto == -1) {
 257 		String scelta;
 258 		do{
 259 		    System.out.println("\nReparto completo. Desidera verificare la disponibilità nell'altro reparto? (si/no).");
 260 		    scelta = input.next();
 261 		}while(! scelta.equals("si") && ! scelta.equals("no"));
 262 		if(scelta.equals("si")) {
 263 		    rep = scambiaReparto(rep);
 264 		    posto = trovaPosto(rep, posti);
 265 		}
 266 	    }
 267 	    
 268 	    if(posto == -1)
 269 		System.out.println("\nIl prossimo volo parte tra 3 ore.\n");
 270 	    else {
 271 		// segna il posto come occupato
 272 		posti[posto] = 1;
 273 		
 274 		// stampa carta d'imbarco
 275 		System.out.println("\nReparto " + repartoToString(rep) + ", posto " + posto + ".\n");
 276 	    }
 277 	}
 278     }
 279 }