Attachment '20100121-Riepilogo-Classi-Ricorsione-Ordinamento-Esercizi-per-casa.txt'
Download 1 ////////////////////////////////////////////////////////////////////////////////
2
3 ////////////////////////////////////////////////////////////////////////////////
4 // FILE ConversioneDiBase.java
5 ////////////////////////////////////////////////////////////////////////////////
6
7 import java.util.Scanner;
8
9 public class ConversioneDiBase {
10
11 public static int cifraEsadecimale(char c) {
12 if('0' <= c && c <= '9')
13 return c - '0';
14 else // 'A' <= c && c <= 'F'
15 return c - 'A' + 10;
16 }
17
18 public static int base16ToBase10(String s) {
19 int ris = 0;
20
21 for(int i = 0; i < s.length(); i++) {
22 int c = cifraEsadecimale(s.charAt(i));
23 ris = ris * 16 + c;
24 }
25
26 return ris;
27 }
28
29 public static void main(String[] args) {
30 System.out.println("Conversione da base 16 a base 10");
31
32 Scanner input = new Scanner(System.in);
33
34 System.out.print("Numero da convertire: ");
35 String s = input.next().toUpperCase();
36 int n = base16ToBase10(s);
37 System.out.println("[" + s + "]_16 = [" + n + "]_10");
38 }
39
40 }
41
42
43 ////////////////////////////////////////////////////////////////////////////////
44
45 ////////////////////////////////////////////////////////////////////////////////
46 // FILE FunzioneRicorsiva1.java
47 ////////////////////////////////////////////////////////////////////////////////
48
49
50 /*
51 * Implementare una funzione f(i) ricorsiva che riceve un intero e restituisce un razionale.
52 * Per i=0 la funzione restituisce 1/2, per i>0 restituisce f(i-1)/2, ovvero f(i-1) diviso 2.
53 *
54 * Implementare inoltre un main che stampi la somma dei primi N razionali della sequenza,
55 * per ogni N = 0, ..., 9.
56 *
57 * Fare uso della classe Razionale.
58 */
59
60 public class FunzioneRicorsiva1 {
61
62 public static Razionale f(int i) {
63 if(i == 0)
64 return new Razionale(1, 2);
65
66 Razionale f1 = f(i-1);
67 f1.moltiplica(new Razionale(1, 2));
68 return f1;
69 }
70
71 public static void main(String[] args) {
72 Razionale s = new Razionale();
73 for(int i = 0; i < 10; i++) {
74 s.somma(f(i));
75 System.out.println(i + ": " + s + " = " + s.toDouble());
76 }
77 }
78
79 }
80
81
82
83 ////////////////////////////////////////////////////////////////////////////////
84
85 ////////////////////////////////////////////////////////////////////////////////
86 // FILE MediaRazionali.java
87 ////////////////////////////////////////////////////////////////////////////////
88
89 /*
90 * Implementare un programma che determini la media di una sequenza di numeri razionali
91 * terminata da un numero razionale negativo.
92 *
93 * Fare uso della classe Razionale.
94 *
95 * ATTENZIONE: I metodi setNumeratore(int) e setDenominatore(int) della classe Razionale
96 * invocano il metodo semplifica(). Pertanto, la media deve essere calcolata dividendo
97 * la somma dei valori per il numero di elementi nella sequenza (come di consueto).
98 */
99
100 import java.util.Scanner;
101
102 public class MediaRazionali {
103
104 public static void main(String[] args) {
105 Scanner input = new Scanner(System.in);
106
107 Razionale media = new Razionale();
108 int count = 0;
109
110 System.out.println("Inserisci una sequenza di numeri razionali (coppie di interi) terminata da un numero razionale negativo.");
111 Razionale x = Razionale.leggi(input);
112 while(x.maggioreDiOUgualeA(new Razionale())) {
113 media.somma(x);
114 count++;
115
116 x = Razionale.leggi(input);
117 }
118
119 media.dividi(new Razionale(count));
120 System.out.println("La media e': " + media + " = " + media.toDouble());
121 }
122
123 }
124
125
126 ////////////////////////////////////////////////////////////////////////////////
127
128 ////////////////////////////////////////////////////////////////////////////////
129 // FILE OperazioniPolinomi.java
130 ////////////////////////////////////////////////////////////////////////////////
131
132 import java.util.Scanner;
133
134 public class OperazioniPolinomi {
135
136 public static void main(String[] args) {
137 Scanner input = new Scanner(System.in);
138 PolinomioCoefficienteRazionali p1 = PolinomioCoefficienteRazionali.leggi(input);
139 System.out.println("Il PolinomioCoefficienteRazionali inserito e': " + p1);
140 PolinomioCoefficienteRazionali p2 = PolinomioCoefficienteRazionali.leggi(input);
141 System.out.println("Il PolinomioCoefficienteRazionali inserito e': " + p2);
142
143 if(p1.equals(p2))
144 System.out.println("I due polinomi sono uguali");
145 else
146 System.out.println("I due polinomi sono diversi");
147
148 PolinomioCoefficienteRazionali p3 = p1.somma(p2);
149 System.out.println("Il PolinomioCoefficienteRazionali risultante dalla loro somma e': " + p3);
150
151 PolinomioCoefficienteRazionali p4 = p1.sottrai(p2);
152 System.out.println("Il PolinomioCoefficienteRazionali risultante dalla loro differenza e': " + p4);
153
154 System.out.println("Inserisci un valore intero per l'incognita x:");
155 Razionale x = Razionale.leggi(input);
156 System.out.println("Il valore del primo PolinomioCoefficienteRazionali per x=" + x + " e': " + p1.valuta(x));
157
158 System.out.println("Inserisci un intervallo in cui cercare eventuali radici (intere) del primo PolinomioCoefficienteRazionali:");
159 System.out.print("Estremo iniziale: ");
160 int inizio = input.nextInt();
161 System.out.print("Estremo finale: ");
162 int fine = input.nextInt();
163 boolean esisteRadice = false;
164 for(int i=inizio; i<=fine; i++)
165 if(p1.eRadice(new Razionale(i))){
166 System.out.println("L'intero " + i + " e' una radice del PolinomioCoefficienteRazionali " + p1);
167 esisteRadice = true;
168 }
169 if(!esisteRadice)
170 System.out.println("Nessuna radice (intera) nell'intervallo considerato");
171
172 }
173
174 }
175
176
177 ////////////////////////////////////////////////////////////////////////////////
178
179 ////////////////////////////////////////////////////////////////////////////////
180 // FILE OrdinaFrase.java
181 ////////////////////////////////////////////////////////////////////////////////
182
183
184 import java.util.Scanner;
185
186
187 public class OrdinaFrase {
188
189 public static int contaParole(String frase) {
190 int count = 0;
191 for(int i = 0; i < frase.length(); i++)
192 if(frase.charAt(i) == '-')
193 count++;
194 return count + 1;
195 }
196
197 public static String prossimaParola(String frase, int start) {
198 String ris = "";
199 while(start < frase.length() && frase.charAt(start) != '-') {
200 ris += frase.charAt(start);
201 start++;
202 }
203 return ris;
204 }
205
206 public static String[] separaParole(String frase) {
207 int n = contaParole(frase);
208 String[] parole = new String[n];
209
210 int j = 0;
211 for(int i = 0; i < n; i++) {
212 parole[i] = prossimaParola(frase, j);
213 j += parole[i].length() + 1;
214 }
215
216 return parole;
217 }
218
219 public static void merge(String[] a, int inf, int mid, int sup) {
220 String[] tmp = new String[a.length];
221
222 int i = inf; // a[inf] ... a[mid]
223 int m = mid+1; // a[mid+1] ... a[sup]
224 int t = inf; // tmp[inf] ... tmp[sup]
225
226 while(i <= mid && m <= sup) {
227 if(a[i].compareTo(a[m]) <= 0) {
228 tmp[t] = a[i];
229 t++;
230 i++;
231 }
232 else {
233 tmp[t] = a[m];
234 t++;
235 m++;
236 }
237 }
238
239 while(i <= mid) {
240 tmp[t] = a[i];
241 t++;
242 i++;
243 }
244
245 while(m <= sup) {
246 tmp[t] = a[m];
247 t++;
248 m++;
249 }
250
251 for(i = inf; i <= sup; i++)
252 a[i] = tmp[i];
253 }
254
255 public static void mergeSort(String[] a, int inf, int sup) {
256 if(inf < sup) {
257 int mid = (inf + sup) / 2;
258 mergeSort(a, inf, mid);
259 mergeSort(a, mid+1, sup);
260 merge(a, inf, mid, sup);
261 }
262 }
263
264 public static String concatena(String[] parole) {
265 String ris = parole[0];
266 for(int i = 1; i < parole.length; i++)
267 ris += '-' + parole[i];
268 return ris;
269 }
270
271 public static String ordina(String frase) {
272 String[] parole = separaParole(frase);
273 mergeSort(parole, 0, parole.length - 1);
274
275 String ris = concatena(parole);
276 return ris;
277 }
278
279 public static void main(String[] args) {
280 System.out.println("Ordinamento frase");
281
282 Scanner input = new Scanner(System.in);
283
284 System.out.print("Frase da ordinare (piu' parole separate da un trattino): ");
285 String frase = input.next();
286 String fraseOrdinata = ordina(frase);
287 System.out.println("La frase ordinata e': " + fraseOrdinata);
288 }
289
290 }
291
292
293 ////////////////////////////////////////////////////////////////////////////////
294
295 ////////////////////////////////////////////////////////////////////////////////
296 // FILE PolinomioCoefficienteRazionali.java
297 ////////////////////////////////////////////////////////////////////////////////
298
299 import java.util.Scanner;
300
301 public class PolinomioCoefficienteRazionali {
302
303 private int grado;
304 private Razionale coeff[];
305
306 private PolinomioCoefficienteRazionali(int g) {
307 grado = g;
308 coeff = new Razionale[g+1];
309 }
310
311 public PolinomioCoefficienteRazionali(PolinomioCoefficienteRazionali p) {
312 grado = p.grado;
313 coeff = new Razionale[grado+1];
314 for(int i=0; i<coeff.length; i++)
315 coeff[i].set(p.coeff[i]);
316 }
317
318 // Versione semplice
319 /* public String toString() {
320 String output = "";
321 for(int i=grado; i>=0; i--)
322 if(coeff[i] != 0) {
323 if(coeff[i] > 0)
324 output += "+";
325 output += coeff[i] + "x^" + i;
326 }
327 return output;
328 }
329 */
330 // Versione + sofisticata
331 public String toString() {
332 String output = "";
333 for(int i=grado; i>=0; i--)
334 if(coeff[i].diversoDa(new Razionale())) {
335 if(coeff[i].maggioreDi(new Razionale()) && i < grado)
336 output += "+";
337 if(coeff[i].equals(new Razionale(-1)) && i > 0)
338 output += "-";
339 else
340 if(coeff[i].diversoDa(new Razionale(1)) || i == 0)
341 output += coeff[i];
342 if(i > 0)
343 output += "x";
344 if(i > 1)
345 output += "^" + i;;
346 }
347 return output;
348 }
349
350 public int getGrado() {
351 return grado;
352 }
353
354 public Razionale getTermine(int g) {
355 if(g < coeff.length)
356 return coeff[g];
357 else
358 return new Razionale();
359 }
360
361 public void setTermine(int g, Razionale t) {
362 if(g < coeff.length)
363 coeff[g].set(t);
364 }
365
366 public boolean equals(PolinomioCoefficienteRazionali p) {
367 if(grado != p.grado)
368 return false;
369 for(int i=0; i<coeff.length; i++)
370 if(coeff[i].diversoDa(p.coeff[i]))
371 return false;
372 return true;
373 }
374
375 public PolinomioCoefficienteRazionali perCostante(Razionale c) {
376 PolinomioCoefficienteRazionali ris = new PolinomioCoefficienteRazionali(grado);
377 for(int i=0; i<=grado; i++) {
378 ris.coeff[i] = new Razionale(coeff[i]);
379 ris.coeff[i].moltiplica(c);
380 }
381 return ris;
382 }
383
384 public PolinomioCoefficienteRazionali somma(PolinomioCoefficienteRazionali p) {
385 PolinomioCoefficienteRazionali somma;
386 if(grado > p.grado)
387 somma = new PolinomioCoefficienteRazionali(grado);
388 else
389 somma = new PolinomioCoefficienteRazionali(p.grado);
390
391 int i = 0;
392 while(i<=grado && i<=p.grado) {
393 somma.coeff[i] = new Razionale(coeff[i]);
394 somma.coeff[i].somma(p.coeff[i]);
395 i++;
396 }
397 while(i<=grado) {
398 somma.coeff[i] = new Razionale(coeff[i]);
399 i++;
400 }
401 while(i<=p.grado) {
402 somma.coeff[i] = new Razionale(p.coeff[i]);
403 i++;
404 }
405 return somma;
406 }
407
408 public PolinomioCoefficienteRazionali sottrai(PolinomioCoefficienteRazionali p) {
409 return somma(p.perCostante(new Razionale(-1)));
410 }
411
412 public Razionale valuta(Razionale x) {
413 Razionale val = new Razionale();
414 for(int i=0; i<=grado; i++) {
415 Razionale tmp = new Razionale(1);
416 for(int j = 0; j < i; j++)
417 tmp.moltiplica(x);
418
419 tmp.moltiplica(coeff[i]);
420 val.somma(tmp);
421 }
422 return val;
423 }
424
425 public boolean eRadice (Razionale x) {
426 return valuta(x).ugualeA(new Razionale());
427 }
428
429 public static PolinomioCoefficienteRazionali leggi(Scanner input) {
430 int g;
431 do {
432 System.out.print("Grado del polinomio: ");
433 g = input.nextInt();
434 if(g < 0)
435 System.out.println("Il grado di un polinomio non pu? essere un numero negativo!!!");
436 } while(g < 0);
437 PolinomioCoefficienteRazionali pol = new PolinomioCoefficienteRazionali(g);
438 System.out.println("Inserisci i coefficienti del polinomio per grado decrescente. ");
439 for (int i=g; i>=0; i--) {
440 System.out.print("Grado " + i + ": ");
441 pol.coeff[i] = Razionale.leggi(input);
442 }
443 return pol;
444 }
445
446 }
447
448
449 ////////////////////////////////////////////////////////////////////////////////
450
451 ////////////////////////////////////////////////////////////////////////////////
452 // FILE ProdottoRazionali.java
453 ////////////////////////////////////////////////////////////////////////////////
454
455 /*
456 * Implementare un programma che determini il prodotto di una sequenza di numeri razionali
457 * terminata da un numero razionale negativo. Il programma deve inoltre stabilire se
458 * tale prodotto รจ minore di 12/7 (dodici settimi) o meno.
459 *
460 * Fare uso della classe Razionale.
461 */
462
463 import java.util.Scanner;
464
465 public class ProdottoRazionali {
466
467 public static void main(String[] args) {
468 Scanner input = new Scanner(System.in);
469
470 Razionale p = new Razionale(1);
471
472 System.out.println("Inserisci una sequenza di numeri razionali (coppie di interi) terminata da un numero razionale negativo.");
473 Razionale x = Razionale.leggi(input);
474 while(x.maggioreDiOUgualeA(new Razionale())) {
475 p.moltiplica(x);
476
477 x = Razionale.leggi(input);
478 }
479
480 System.out.println("Il prodotto e': " + p + " = " + p.toDouble());
481
482 Razionale r = new Razionale(12, 7);
483 if(p.minoreDi(r))
484 System.out.println("Il prodotto e' minore di " + r + " = " + r.toDouble());
485 else
486 System.out.println("Il prodotto non e' minore di " + r + " = " + r.toDouble());
487 }
488
489 }
490
491
492 ////////////////////////////////////////////////////////////////////////////////
493
494 ////////////////////////////////////////////////////////////////////////////////
495 // FILE Razionale.java
496 ////////////////////////////////////////////////////////////////////////////////
497
498 import java.util.Scanner;
499
500
501 public class Razionale {
502
503 private int numeratore;
504 private int denominatore;
505
506 public Razionale(int numeratore, int denominatore) {
507 this.numeratore = numeratore;
508 this.setDenominatore(denominatore);
509 }
510
511 public Razionale(int numeratore) {
512 this.numeratore = numeratore;
513 this.denominatore = 1;
514 }
515
516 public Razionale() {
517 this.numeratore = 0;
518 this.denominatore = 1;
519 }
520
521 public Razionale(Razionale r) {
522 this.set(r);
523 }
524
525 public String toString() {
526 return this.numeratore + "/" + this.denominatore;
527 }
528
529 public double toDouble() {
530 return this.numeratore / (double) this.denominatore;
531 }
532
533 public int getNumeratore() {
534 return numeratore;
535 }
536
537 public void setNumeratore(int numeratore) {
538 this.numeratore = numeratore;
539 this.semplifica();
540 }
541
542 public int getDenominatore() {
543 return denominatore;
544 }
545
546 public void setDenominatore(int denominatore) {
547 if(denominatore != 0) {
548 this.denominatore = denominatore;
549 this.semplifica();
550 }
551 else // se denominatore e' 0 lo settiamo a 1 per evitare una divisione per zero
552 // (ma l'utente dovrebbe evitare di settare il denominatore a zero)
553 this.denominatore = 1;
554 }
555
556 public void set(Razionale r) {
557 this.numeratore = r.numeratore;
558 this.denominatore = r.denominatore;
559 }
560
561 private void semplifica() {
562 if(this.denominatore < 0) {
563 this.numeratore *= -1;
564 this.denominatore *= -1;
565 }
566
567 int d = Razionale.mcd(Math.abs(this.numeratore), denominatore);
568 this.numeratore /= d;
569 this.denominatore /= d;
570 }
571
572 private static int mcd(int a, int b) {
573 while(true) {
574 if(a == 0)
575 return b;
576 if(b == 0)
577 return a;
578
579 if(a > b)
580 a -= b;
581 else
582 b -= a;
583 }
584 }
585
586 public boolean ugualeA(Razionale r) {
587 return this.toDouble() == r.toDouble();
588 }
589 public boolean diversoDa(Razionale r) {
590 return !this.ugualeA(r);
591 }
592 public boolean minoreDi(Razionale r) {
593 return this.toDouble() < r.toDouble();
594 }
595 public boolean minoreDiOUgualeA(Razionale r) {
596 return this.toDouble() <= r.toDouble();
597 }
598 public boolean maggioreDi(Razionale r) {
599 return this.toDouble() > r.toDouble();
600 }
601 public boolean maggioreDiOUgualeA(Razionale r) {
602 return this.toDouble() >= r.toDouble();
603 }
604
605 public void moltiplica(Razionale r) {
606 this.numeratore *= r.numeratore;
607 this.denominatore *= r.denominatore;
608 this.semplifica();
609 }
610
611 public void dividi(Razionale r) {
612 Razionale tmp = new Razionale(r);
613 tmp.inverti();
614 this.moltiplica(tmp);
615 }
616
617 public void inverti() {
618 if(this.numeratore != 0) {
619 int tmp = this.numeratore;
620 this.numeratore = this.denominatore;
621 this.denominatore = tmp;
622 this.semplifica();
623 }
624 }
625
626 public void somma(Razionale r) {
627 this.numeratore = this.numeratore * r.denominatore + r.numeratore * this.denominatore;
628 this.denominatore *= r.denominatore;
629 this.semplifica();
630 }
631
632 public void sottrai(Razionale r) {
633 Razionale tmp = new Razionale(r);
634 tmp.moltiplica(new Razionale(-1));
635 this.somma(tmp);
636 }
637
638 public static Razionale leggi(Scanner input) {
639 System.out.print("Numeratore: ");
640 int n = input.nextInt();
641 System.out.print("Denominatore: ");
642 int d = input.nextInt();
643 System.out.println();
644 return new Razionale(n, d);
645 }
646
647 }
648
649
650
651 ////////////////////////////////////////////////////////////////////////////////
652
653 ////////////////////////////////////////////////////////////////////////////////
654 // FILE SequenzaStrettmenteCrescente.java
655 ////////////////////////////////////////////////////////////////////////////////
656
657 /*
658 * Implementare un programma che determini se una sequenza di numeri razionali
659 * terminata da un numero razionale negativo e' strettamente crescente o meno.
660 *
661 * Fare uso della classe Razionale.
662 */
663
664 import java.util.Scanner;
665
666 public class SequenzaStrettamenteCrescente {
667
668 public static void main(String[] args) {
669 Scanner input = new Scanner(System.in);
670
671 System.out.println("Inserisci una sequenza di numeri razionali (coppie di interi) terminata da un numero razionale negativo.");
672
673 boolean strettamenteCrescente = true;
674 Razionale prec = Razionale.leggi(input);
675 Razionale succ = Razionale.leggi(input);
676
677 while(succ.maggioreDiOUgualeA(new Razionale())) {
678 if(!succ.maggioreDi(prec))
679 strettamenteCrescente = false;
680
681 prec = succ;
682 succ = Razionale.leggi(input);
683 }
684
685 if(strettamenteCrescente)
686 System.out.println("Sequenza strettamente crescente");
687 else
688 System.out.println("Sequenza non strettamente crescente");
689 }
690
691 }
692
693
694
695 ////////////////////////////////////////////////////////////////////////////////
696
697 ////////////////////////////////////////////////////////////////////////////////
698 // FILE VerificaSommaIntera.java
699 ////////////////////////////////////////////////////////////////////////////////
700
701 /*
702 * Implementare un programma che determini la somma di una sequenza di numeri razionali
703 * terminata da un numero razionale negativo. Il programma deve inoltre stabilire se
704 * tale somma รจ un numero intero o meno.
705 *
706 * Fare uso della classe Razionale.
707 */
708
709 import java.util.Scanner;
710
711 public class VerificaSommaIntera {
712
713 public static void main(String[] args) {
714 Scanner input = new Scanner(System.in);
715
716 Razionale s = new Razionale();
717
718 System.out.println("Inserisci una sequenza di numeri razionali (coppie di interi) terminata da un numero razionale negativo.");
719 Razionale x = Razionale.leggi(input);
720 while(x.maggioreDiOUgualeA(new Razionale())) {
721 s.somma(x);
722
723 x = Razionale.leggi(input);
724 }
725
726 if(s.getDenominatore() == 1)
727 System.out.println("La somma e': " + s.toDouble() + " (un numero intero)");
728 else
729 System.out.println("La somma e': " + s + " (un numero non intero)");
730 }
731
732 }
733
734
735
736 ////////////////////////////////////////////////////////////////////////////////
737
738 ////////////////////////////////////////////////////////////////////////////////
739 // FILE FunzioneRicorsiva2.java
740 ////////////////////////////////////////////////////////////////////////////////
741
742
743 /*
744 * Implementare una funzione f(i) ricorsiva che riceve un intero e restituisce un razionale.
745 * Per i=0 la funzione restituisce 0,
746 * per i=1 la funzione restituisce 1,
747 * per i>1 restituisce (f(i-2) + f(i-1))/2, ovvero la media fra f(i-2) e f(i-1).
748 *
749 * Implementare inoltre un main che stampi i primi 10 razionali della sequenza.
750 *
751 * Fare uso della classe Razionale.
752 */
753
754 public class FunzioneRicorsiva2 {
755
756 }
757
758
759
760 ////////////////////////////////////////////////////////////////////////////////
761
762 ////////////////////////////////////////////////////////////////////////////////
763 // FILE SequenzaStrettamenteDecrescente.java
764 ////////////////////////////////////////////////////////////////////////////////
765
766 /*
767 * Implementare un programma che determini se una sequenza di numeri razionali
768 * terminata da un numero razionale negativo e' strettamente decrescente o meno.
769 *
770 * Fare uso della classe Razionale.
771 */
772
773 public class SequenzaStrettamenteDecrescente {
774
775 public static void main(String[] args) {
776
777 }
778
779 }
780
781
782
783 ////////////////////////////////////////////////////////////////////////////////
784
785 ////////////////////////////////////////////////////////////////////////////////
786 // FILE SequenzaSegnoAlterno.java
787 ////////////////////////////////////////////////////////////////////////////////
788
789 /*
790 * Implementare un programma che determini se una sequenza di N numeri razionali
791 * e' a segni alterni (ogni numero positivo e' seguito da un numero negativo e viceversa).
792 * Per semplicita', assumere che lo zero faccia parte dei numeri positivi.
793 *
794 * Fare uso della classe Razionale.
795 */
796
797 public class SequenzaSegnoAlterno {
798
799 public static void main(String[] args) {
800
801 }
802
803 }
Attached Files
You are not allowed to attach a file to this page.