Attachment '20091118-EsercitazioneLAB-Funzioni-SOLUZIONI.txt'
Download 1 // Scrivere in Java un programma (che sfrutti adeguatamente dei metodi statici)
2 // che, letto da input un numero intero, sia N, PRIMA stampi il numero speculato
3 // di N (ovvero il numero con le stesse cifre di N, ma in posizioni opposte), e POI
4 // ne stampi la scomposizione in base 10 di N (unita', decine, centinaia, etc...).
5 // ESEMPIO: se il numero inserito fosse
6 //
7 // 8723
8 //
9 // il programma dovrebbe PRIMA stampare
10 //
11 // 8723 speculato = 3278
12 //
13 // e POI stampare
14 //
15 // 8723 = 3*10^0 + 2*10^1 + 7*10^2 + 8*10^3
16
17
18 import java.util.*;
19
20 public class ScomposizioneNumero {
21
22 public static Scanner input = new Scanner(System.in);
23
24 public static void stampaInverso(int numero) {
25 while(numero > 0) {
26 System.out.print(numero % 10);
27 numero /= 10;
28 }
29 }
30
31 public static void stampaScomposizioneBase10(int numero) {
32 int exp = 0; // l'esponente
33 while(numero > 0) {
34 System.out.print( (numero % 10) + "*10^" + exp);
35 numero /= 10;
36 if (numero > 0)
37 System.out.print(" + ");
38 exp++;
39 }
40 }
41
42 public static void main(String[] args) {
43 System.out.print("Inserisci un numero intero: ");
44 int numero = input.nextInt();
45 System.out.print("Numero: " + numero + " - il numero inverso e' ");
46 stampaInverso(numero);
47 System.out.println();
48 System.out.print("Numero: " + numero + " - la scomposizione in base 10 e' ");
49 stampaScomposizioneBase10(numero);
50 }
51 }
52
53
54 /////////////////////////////////////////////////////////////////////////////////////////////
55
56 // Scrivere in Java un programma (che sfrutti adeguatamente dei metodi statici) con
57 // lo scopo di aiutare un alunno della scuola elementare ad imparare le 4
58 // operazioni (addizione, sottrazione, moltiplicazione e divisione). Il programma
59 // dovrebbe porre allalunno domande del tipo: "Quanto fa 6 * 7?". Lalunno digita
60 // la risposta. Il programma la controlla e, se è corretta visualizza una a caso
61 // fra queste 3 frasi: "Bravo!" - "Eccellente!" - "Ottimo Lavoro!", e passa alla
62 // domanda successiva. Se la risposta è sbagliata, il programma visualizza una
63 // frase tra le seguenti: "No, riprova!" - "Sbagliato. Prova ancora!" - "Non ti
64 // arrendere, riprova!", e consente allalunno di riprovare finché (si spera) non
65 // dà la risposta corretta. Le domande da porre allalunno devono essere
66 // completamente casuali, cioè sia gli operandi che gli operatori devono essere
67 // scelti in modo random. Gli operandi devono essere interi positivi di una cifra
68 // sola. Nel caso in cui loperatore estratto sia la divisione, lalunno deve
69 // inserire come risultato solo la parte intera. Variante 1: Modificare il
70 // programma in modo che dopo 3 risposte sbagliate venga visualizzato il risultato
71 // delloperazione e si passi alla domanda successiva.
72
73
74 import java.util.*;
75
76 public class OperazioniAritmetiche {
77
78 public static Scanner input = new Scanner(System.in);
79 public static Random generatore = new Random();
80
81 public static void main(String[] args)
82 {
83 System.out.println(" * Giochiamo con le quattro operazioni *");
84 char scelta;
85 do {
86 int risultato = FaiDomanda();
87 int risposta = input.nextInt();
88
89 verificaRisposta(risultato, risposta);
90
91 System.out.print(" Vuoi giocare ancora? (s|n) ");
92 scelta = input.next().charAt(0);
93 }
94 while( scelta != 'n' && scelta != 'N');
95 System.out.println(" * Grazie per aver giocato con noi... alla prossima! :) ");
96 }
97
98 public static int FaiDomanda()
99 {
100 int n1 = 1 + generatore.nextInt(10);
101 int n2 = 1 + generatore.nextInt(10);
102 int op = generatore.nextInt(4);
103 int risultato;
104 char operazione;
105 switch(op)
106 {
107 case 0:
108 operazione = '+';
109 risultato = n1 + n2;
110 break;
111 case 1:
112 operazione = '-';
113 risultato = n1 - n2;
114 break;
115 case 2:
116 operazione = '*';
117 risultato = n1 * n2;
118 break;
119 default:
120 operazione = '/';
121 risultato = n1 / n2;
122 break;
123 }
124 System.out.println("Allora... Quanto fa " + n1 + " " + operazione + " " + n2 + " ? ");
125 return risultato;
126 }
127
128 public static void verificaRisposta(int ris, int risp)
129 {
130 int cont = 1;
131 while ( ris != risp && cont < 10 )
132 {
133 stampaFraseNegativa();
134 risp = input.nextInt();
135 cont++;
136 }
137 if ( ris == risp )
138 stampaFrasePositiva();
139 else
140 System.out.println(" Non sei riuscito ad indovinare... :( La risposta corretta era " + ris);
141 }
142
143 public static void stampaFraseNegativa()
144 {
145 int frase = generatore.nextInt(4);
146 String messaggio;
147 switch(frase)
148 {
149 case 0:
150 messaggio = " No, riprova! ";
151 break;
152 case 1:
153 messaggio = " Sbagliato. Prova ancora! ";
154 break;
155 case 2:
156 messaggio = " Errore... Non ti arrendere, riprova! ";
157 break;
158 default:
159 messaggio = " Niente da fare, prova ancora! ";
160 }
161 System.out.println(messaggio);
162 }
163
164 public static void stampaFrasePositiva()
165 {
166 int frase = generatore.nextInt(4);
167 String messaggio;
168 switch(frase)
169 {
170 case 0:
171 messaggio = " Bravo! ";
172 break;
173 case 1:
174 messaggio = " Corretto! Eccellente! ";
175 break;
176 case 2:
177 messaggio = " Esatto! Continuta così! ";
178 break;
179 default:
180 messaggio = " Sì! Ottimo lavoro! ";
181 }
182 System.out.println(messaggio);
183 }
184 }
185
186
187 /////////////////////////////////////////////////////////////////////////////////////////////
188
189
190 // Si scriva un adeguato programma Java che, sfruttando adeguatamente dei metodi statici,
191 // operi su due sequenze di numeri interi positivi secondo quanto descritto di seguito.
192 // Siano dette A e B due sequenze di numeri interi positivi terminate
193 // da un tappo negativo, e sia quindi detto x il numero di elementi PARI nella
194 // sequenza A. Si intende prima calcolare x, e quindi contare quante volte
195 // x è contenuto nella sequenza B. Esempio: per le sequenze
196 // A = 2 3 4 12 32 65 7 -1
197 // B = 4 65 23 75 2 4 -1
198 // ci sono x=4 numeri pari in A; e il numero 4 è contenuto 2 volte in B.
199
200 import java.util.*;
201
202 public class ContaPariContaNumero {
203
204 public static Scanner input = new Scanner(System.in);
205
206 public static int contaPari() {
207 int conta = 0;
208 int n = input.nextInt();
209 while ( n>=0) {
210 if ( n%2 == 0 )
211 conta++;
212 n = input.nextInt();
213 }
214 return conta;
215 }
216
217 public static int contaOccorrenze(int x) {
218 int conta = 0;
219 int n = input.nextInt();
220 while ( n>=0) {
221 if ( n == x )
222 conta++;
223 n = input.nextInt();
224 }
225 return conta;
226 }
227
228
229 public static void main(String[] args) {
230 System.out.println("Inserire la PRIMA sequenza di numeri interi positivi, terminare con un numero negativo.");
231 int x = contaPari(); // x = numero elementi PARI nella sequenza A
232 System.out.println("Inserire la SECONDA sequenza di numeri interi positivi, terminare con un numero negativo.");
233 int c = contaOccorrenze(x); // numero di elementi pari a x nella sequenza B
234
235 System.out.println("Nella PRIMA sequenza erano presenti " + x + " numeri pari.");
236 System.out.println("Nella SECONDA sequenza, il numero " + x + " era presente " + c + " volte.");
237
238 }
239 }
Attached Files
You are not allowed to attach a file to this page.