SCIENZE E TECNOLOGIE INFORMATICHE

[:it]

roger de la fresnaye

Il nucleo della soluzione è il seguente:

massimo=-1000
minimo=1000
media=0
for i in range (1,4):
a=input(“valore: “)
a=float(a)
media=media+a
if (a>massimo):
massimo=a
if (a<minimo):
minimo=a
media=media/3
print(“media “, media)
print(“massimo “,massimo)
print(“mnimio “, minimo)

Tale ciclo si ripete per le due dimensioni da inserire.[:]

[:it]

Roberto Bergonzo, Società Pres – L’asseedio, olio su tela cm.230×90

Questa versione, in un unico ciclo si immettono i valori e si calcola la media ed il valore massimo

• si notino i commenti per spiegare ogni fase del programma
• si utilizzi il corretto incolonnamento per meglio evidenziare i vari cicli.
• Ho utilizzato due cicli for ma  si potevano ovviamente calcolare anche dei cicli while.

/*
author: francesco bragadin
data: 26/11/2017
oggetto: calcolo della superficie di un tavolo senza
l’uso di un vettore immettendo dieci valori
delle rispettive misure calcolando l’errore
*/

#include<iostream>

using namespace std;
int main(){

double a,b;
double Amax,Amin,Amedia,Aerr;
double Bmax,Bmin,Bmedia,Berr;
double area;
double areaerr;
int k;
Amax=-1000;
Amin=1000;
Bmax=-1000;
Bmin=1000;

/* si chiede a chi usa il programma quanti sono i valori da immettere */

cout<<“quanti valori si immettono?”<<“\n”;
cin>>k;

/* ciclo per la prima dimensione per immettere i valori e per caloclare la medeia e il valore massimo */

for (int i=0;i<k;i++){
cout<<“immetere il valore: “;
cin>>a;
Amedia=Amedia+a;
if (a>Amax)
Amax=a;
if (a<Amin)
Amin=a;
}

/* Calcolo della media e errore sulla misura */

Amedia=Amedia/k;
Aerr=(Amax-Amin)/2;

/* questa parte anche se non obbligtoria funziona per verificare la correttezza degli algoritmi usati */

cout<<“la media risulta: “<<Amedia<<endl;
cout<<“il minimo risulta: “<<Amin<<endl;
cout<<“il massimo risulta:”<<Amax<<endl;
cout<<“Errore risulta “<<Aerr<<endl;

/* ciclo per la seconda dimensione per immettere i valori e per calcolare la medeia e il valore massimo */

for (int i=0;i<k;i++){
cout<<“immetere il valore: “;
cin>>b;
Bmedia=Bmedia+b;
if (b>Bmax)
Bmax=b;
if (b<Bmin)
Bmin=b;
}

/* Calcolo media ed errore sulla misura */

Bmedia=Bmedia/k;
Berr=(Bmax-Bmin)/2;

/* questa parte anche se non obbligtoria funziona per verificare la correttezza degli algoritmi usati */

cout<<“la media risulta: “<<Bmedia<<endl;
cout<<“il minimo risulta: “<<Bmin<<endl;
cout<<“il massimo risulta:”<<Bmax<<endl;
cout<<“Errore risulta “<<Berr<<endl;

/* calcolo della superficie */

areaerr=Amedia*Aerr+Bmedia*Berr;
area=Amedia*Bmedia;

cout<<“area: “<<area<<” +/- “<<areaerr;

}[:]

[:it]

Roberto Bergonzo, Fiat Gsa 2000, olio su tela, cm.130×130

Questa soluzione non è efficiente dal punto di vista della complessità computazionale in quanto effettuo numerosissimi cicli che potrebbero benissimo essere raggruppati in un solo.

In ogni caso esso è un esempi di come si è utilizzato una sequenzialità delle istruzioni immesse suddividendola in momenti diversi.

/*
author: francesco bragadin
data: 26/11/2017
oggetto: calcolo della superficie di un tavolo senza
l’uso di un vettore immettendo dieci valori
delle rispettive misure calcolando l’errore
*/

#include<iostream>
using namespace std;
int main(){
double a0,a1,a2,a3,a4,a5,a6,a7,a8,a9;
double b0,b1,b2,b3,b4,b5,b6,b7,b8,b9;
double amax,amin;
double amedia;
double aerr;
double bmax,bmin;
double bmedia;
double berr;
int const k=10;
double areaerr;
double area;
/*
ciclo per l’inserimeto dei valori della base
*/

for (int i=0;i<k;i++)
{
cout<<“Inserisci il valore a”<<i<<“\n”;
switch(i){
case 0:
cin>>a0;
break;
case 1:
cin>>a1;
break;
case 2:
cin>>a2;
break;
case 3:
cin>>a3;
break;
case 4:
cin>>a4;
break;
case 5:
cin>>a5;
break;
case 6:
cin>>a6;
break;
case 7:
cin>>a7;
break;
case 8:
cin>>a8;
break;
case 9:
cin>>a9;
break;
default:
cout<<“Errore”;
break;
}

}
/*
verifico la correttezza dei valori inseriti
*/

cout<<“Ecco i valori inseriti”<<“\n”;
cout<<a0<<” “<<a1<<” “<<a2<<” “<<a3<<” “<<a4<<” “<<a5<<” “<<a6<<” “<<a7<<” “<<a8<<” “<<a9<<“\n”;

/*
ciclo per prendere il valore piu’ grande
*/

for (int i=0;i<k;i++)
{
switch(i){
case 0:
amax=a0;
break;
case 1:
if (a1>amax)
amax=a1;
break;
case 2:
if (a2>amax)
amax=a2;
break;
case 3:
if (a3>amax)
amax=a3;
break;
case 4:
if (a4>amax)
amax=a4;
break;
case 5:
if (a5>amax)
amax=a5;
break;
case 6:
if (a6>amax)
amax=a6;
break;
case 7:
if (a7>amax)
amax=a7;
break;
case 8:
if (a8>amax)
amax=a8;
break;
case 9:
if (a9>amax)
amax=a9;
break;
default:
cout<<“Errore”;
break;

}
}

cout<<“Valore maggiore: “<<amax<<“\n”;

/*
ciclo per prendere il valore piu’ piccolo
*/

for (int i=0;i<k;i++)
{
switch(i){
case 0:
amin=a0;
break;
case 1:
if (a1<amin)
amin=a1;
break;
case 2:
if (a2<amin)
amin=a2;
break;
case 3:
if (a3<amin)
amin=a3;
break;
case 4:
if (a4<amin)
amin=a4;
break;
case 5:
if (a5<amin)
amin=a5;
break;
case 6:
if (a6<amin)
amin=a6;
break;
case 7:
if (a7<amin)
amin=a7;
break;
case 8:
if (a8<amin)
amin=a8;
break;
case 9:
if (a9<amin)
amin=a9;
break;
default:
cout<<“Errore”;
break;
}
}

cout<<“Valore minore: “<<amin<<“\n”;

/*
errore
*/
aerr=(amax-amin)/2;

/*
media
*/

amedia=(a0+a1+a2+a3+a4+a5+a6+a7+a8+a9)/k;

cout<<“la base risula “<<amedia<<” +/- “<<aerr<<“\n”;

/*************************************************/

/*
ciclo per l’inserimeto dei valori della altezza
*/
int i=0;
while (i<k)
{
cout<<“Inserisci il valore b”<<i<<“\n”;
switch(i){
case 0:
cin>>b0;
break;
case 1:
cin>>b1;
break;
case 2:
cin>>b2;
break;
case 3:
cin>>b3;
break;
case 4:
cin>>b4;
break;
case 5:
cin>>b5;
break;
case 6:
cin>>b6;
break;
case 7:
cin>>b7;
break;
case 8:
cin>>b8;
break;
case 9:
cin>>b9;
break;
default:
cout<<“Errore”;
break;
}
i++;

}
/*
verifico la correttezza dei valori inseriti
*/

cout<<“Ecco i valori inseriti”<<“\n”;
cout<<b0<<” “<<b1<<” “<<b2<<” “<<b3<<” “<<b4<<” “<<b5<<” “<<b6<<” “<<b7<<” “<<b8<<” “<<b9<<“\n”;

/*
ciclo per prendere il valore piu’ grande
*/

for (int i=0;i<k;i++)
{
switch(i){
case 0:
bmax=b0;
break;
case 1:
if (b1>bmax)
bmax=b1;
break;
case 2:
if (b2>bmax)
bmax=b2;
break;
case 3:
if (b3>bmax)
bmax=b3;
break;
case 4:
if (b4>bmax)
bmax=b4;
break;
case 5:
if (b5>bmax)
bmax=b5;
break;
case 6:
if (b6>bmax)
bmax=b6;
break;
case 7:
if (b7>bmax)
bmax=b7;
break;
case 8:
if (b8>bmax)
bmax=b8;
break;
case 9:
if (b9>bmax)
bmax=b9;
break;
default:
cout<<“Errore”;
break;

}
}

cout<<“Valore maggiore: “<<bmax<<“\n”;

/*
ciclo per prendere il valore piu’ piccolo
*/

for (int i=0;i<k;i++)
{
switch(i){
case 0:
bmin=b0;
break;
case 1:
if (b1<bmin)
bmin=b1;
break;
case 2:
if (b2<bmin)
bmin=b2;
break;
case 3:
if (b3<bmin)
bmin=b3;
break;
case 4:
if (b4<bmin)
bmin=b4;
break;
case 5:
if (b5<bmin)
bmin=b5;
break;
case 6:
if (b6<bmin)
bmin=b6;
break;
case 7:
if (b7<bmin)
bmin=b7;
break;
case 8:
if (a8<bmin)
bmin=a8;
break;
case 9:
if (a9<bmin)
bmin=a9;
break;
default:
cout<<“Errore”;
break;
}
}

cout<<“Valore minore: “<<bmin<<“\n”;

/*
errore
*/
berr=(bmax-bmin)/2;

/*
media
*/

bmedia=(b0+b1+b2+b3+b4+b5+b6+b7+b8+b9)/k;

cout<<“la base risula “<<bmedia<<” +/- “<<berr<<“\n”;

areaerr=amedia*aerr+amedia*berr;
area=amedia*bmedia;

cout<<“area: “<<area<<” +/- “<<areaerr;

return 0;
}[:]

[:it]

Picabia

[WpProQuiz 52][:]

[:it]

Roberto Bergonzo

[WpProQuiz 54][:]

[:it]

Ivan Slavinsky

Siano dati dieci valori relativi ad una dimensione di un tavolo, ed altri dieci relativi all’altra dimensione (come da tabella 1). Si calcoli la superficie del tavolo considerando il relativo errore sulla misura, prendendo la corretta relazione che esprime le incertezza nella misura nel caso specifico.

Tabella 1 dei valori:

Per ogni dimensione si dovrà calcolare:

• il valore medio che è dato dalla somma dei valori diviso il numero dei valori

• l’errore massimo che è dato come la differenza tra il valore più grande ed il valore più piccolo

in generale quindi una grandezza si esprime come:

Tabella 2 che esprime i valori delle grandezze derivate e corrispondenti incertezze

Grandezza	Valore più plausibile	Errore
a+b		Err(a)+Err(b)
a-b		Err(a)+Err(b)

Specifiche di programmazione e relativo punteggio:

 [:]

[:it]

roberto bergonzo

[WpProQuiz 53][:]

[:it]

Ivan Slavinsky

1. costruire un programma che accetta da tastiera dei numeri finché viene inserito il valore 0; man mano li visualizza.

2. costruire un programma che accetta da tastiera dei caratteri e li conti. L’inserimento si interrompe quando il numero dei caratteri inseriti diventa 10;

3. dato un elenco di nomi con le rispettive città, conta quanti sono quelli di Milano;

4. dato un elenco di prodotti con i rispettivi prezzi, conta quanti sono quelli che hanno il prezzo superiore a 100€.

5. Dato un elenco di prodotti con descrizione e prezzo, calcolare l’incremento del prezzo secondo una percentuale fornita da tastiera. Comunicare per ciascun prodotto la descrizione ed il prezzo incrementato.

6. Calcolare il consumo medio di carburante di un elenco di veicoli utilizzando come dati di input i valori dei Km percorsi e dei litri di carburante per ciascun veicolo.

7. Riscrivere il seguente frammento di codice usando l’istruzione for

a=0
while a<=10:
     print(a)
     a=a+1

8. Riscrivere il seguente frammento di codice utilizzando l’istruzione for

a=0
while a<=10:
     a=a+1
print(a)

9. costruire un programma che accetta da tastiera un elenco di N pezzi e li sommi. Alla fine fornisce il totale dei pezzi inseriti.

10. Dato un elenco di 20 studenti della prima classe della scuola superiore, con voto finale della scuola media, calcolare il valore medio dei voti.

11. Dati N studenti partecipanti ad una gara sportiva di velocità (nome studente, categoria, tempo) visualizzare il tempo dello studente vincitore (tempo minimo) tra gli studenti della categoria allievi.

12. Dati N modelli di cilomotori e motoclicli (nome del modello, cilindrata, prezzo), visualizzare il prezzo massimo tra i modelli di cilindrata superiore a 50 cc.[:]

[:it]

ivan slavinsky

Esiste un metodo particolare che ha lo stesso nome della classe di partenza: questo è il costruttore della classe, ovvero il metodo che viene automaticamente invocato quando si istanzia un oggetto a partire dalla classe stessa. 

Esso serve per allocare un’opportuna area di memoria e dedicarla all’oggetto che si è creato o meglio si è istanziato.

Uno delle caratteristiche fondamentali del linguaggio Java è la rimozione automatica degli oggetti non più utilizzati liberando lo sviluppatore software da questa incombenza. Tutti gli oggetti istanziati, in un programma Java, sono individuati da un riferimento alla posizione che occupano nello Heap.

Heap: significa letteralmente cumulo, ossia è l’area di memoria nella quale sono allocati gli oggetti istanziati a partire dalle classi utilizzando la parola chiave new del lingiaggio; all’inizio dell’esecuzione di un programma lo heap viene allocato in base ad una dimensione predeterminata, ma nel corso dell’esecuzione la dimensione si adatta dinamicamente al numero ed alla dimensione deglo oggetti creati.

La JVM attiva periodicamente la garbage collector (letteralmente “raccoglitore di spazzatura”) che è in grado di rilevare gli oggetti non più riferiti per recuperare l’area di memoria da essi occupata per renderla nuovamente disponibile.

Questo esempio mette in evidenza moltissime cose:

public class costruttore {
private int a;
private int b;

public costruttore(int a, int b) {
this.a=a;
this.b=b;
}

public int area() {
int c;
c=a*b;
return c;
}

public static void main(String[] args) {
costruttore x;
x= new costruttore(3,4);
System.out.println(x.area());
}

}

• Ho definito due variabili private

private int a;
private int b;

significa che possono essere viste solo all’interno della classe costruttore e tutti i suoi metodi possono usarle. Per meglio capire la differenza; la variabile c, che è usata nel metodo area, esiste solo nel metodo area ma non può essere usata nel metodo main perché non è visibile.

• ecco il costruttore

public costruttore(int a, int b) {
this.a=a;
this.b=b;
}

usa lo stesso nome della classe, gli argomenti del metodo costruttore devono essere dello stesso tipo delle variabili private precedentemente definite e pure con lo stesso nome

(provate a cambiare il tipo e mettere un nome diverso! Si vedrà che non si riesce a creare l’oggetto)

la parola this permette l’assegnazione alla variabile a del metodo costruttore del valore a della classe quando viene istanziata. In pratica si passa al metodo costruttore i valori di a e di b, come in una normale funzione e l’area di memoria acquisisce quel valore.

• nella funzione main inizializzo con opportuni valori gli oggetti della classe costruttore.

x= new costruttore(3,4);

la parola chiave new chiama il metodo costruttore passandogli i valori 3 e 4.[:]

[:it]

ivan slavinsky

Questo esempio contempla al suo interno tutte le strutture di controllo applicate al linguaggio JAVA.

import java.io.InputStreamReader;
import java.io.BufferedReader ;
import java.io.IOException;

public class strutture {

public static void main(String[] args) {
int a,n;
a=0;
n=0;
System.out.println(“inserisci un numero intero”);
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
try {
a = Integer.parseInt(input.readLine());
}
catch (Exception e) {
e.printStackTrace();
}
/**
* Struttura di controllo if
*/
if (a>0)
System.out.println(“a positivo”);
else
System.out.println(“a negativo”);

System.out.println(“inserisci un numero intero”);
BufferedReader input2 = new BufferedReader(new InputStreamReader(System.in));
try {
n = Integer.parseInt(input2.readLine());
}
catch (Exception e) {
e.printStackTrace();
}

/**
* struttura di controllo switch
*/
switch (n) {
case 1:
System.out.println(“hai inserito 1”);
break;
case 2:
System.out.println(“hai inserito 2”);
break;
default:
System.out.println(“Non hai inserito nè 1 nè 2”);
break;
}

/**
* struttura di controllo for
*/
int k=2;
System.out.println(“Tabellina del 2 su una riga”);
for(int j=1;j<11;j++)
System.out.print(k*j+” “);

System.out.println();

/**
* If nidificati
*/
System.out.println(“Tavola pitagorica”);

for(int j=1;j<11;j++)
{
for (int m=1;m<11;m++)
System.out.print(j*m+” “);
System.out.println();
}

int d,g;
d=5;
g=0;
/**
* Ripetizione precondizionale
*/
System.out.println(“Ripetizione precondizionale”);

System.out.println(“inserisci un numero intero come password”);
BufferedReader input15 = new BufferedReader(new InputStreamReader(System.in));
try {
g = Integer.parseInt(input15.readLine());
}
catch (Exception e) {
e.printStackTrace();
}

while(g!=d)
{
System.out.println(“inserisci un numero intero come password”);
BufferedReader input17 = new BufferedReader(new InputStreamReader(System.in));
try {
g = Integer.parseInt(input17.readLine());
}
catch (Exception e) {
e.printStackTrace();
}
}

/**
* Ripetizione condizionale
*/
System.out.println(“Ripetizione condizionale”);

do {
System.out.println(“inserisci un numero intero come password”);
BufferedReader input20 = new BufferedReader(new InputStreamReader(System.in));
try {
g = Integer.parseInt(input20.readLine());
}
catch (Exception e) {
e.printStackTrace();
}

} while (g!=d);

}

}[:]