Attachment '20091202-EsercitazioneLAB-Ricorsione-Array-SOLUZIONI.txt'
Download 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 arraty;
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 }
Attached Files
You are not allowed to attach a file to this page.