SCIENZE E TECNOLOGIE INFORMATICHE

[:it]

roger de la fresnaye

Questo breve programma richiede in input una stringa per poi stamparla:

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

public class parola {
public static void main(String[] args ) {
     String x=null;
    System.out.println(“inseirsci una parola”);
       BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
try {
       x=input.readLine();
}
catch (Exception e) {
e.printStackTrace();
}
System.out.println(x);

}

}

si noti

• che a differenza dei dati numeri che devono essere sottoposti a modifica di tipo, Java legge sempre stringhe.
• le variabili definite all’interno del metodo main devono sempre essere inizializzate, nel caso specifico è messo a null.

con questa riga di codice si ha la lunghezza della stringa immessa:

lung=x.length();[:]

[:it]La funzione distribuzione di probabilità viene utilizzata per descrivere un fenomeno aleatorio (casuale) e fornire la probabilità che un certo evento accada o meno.

In particolare essa segue gli assiomi di Kolmogrov generalizzandoli.

La funzione distribuzione viene così definita:

conseguenza immediata è che:

che ricorda moltissimo il teorema del calcolo integrale ed il teorema di Torricelli-Barrow

Infatti si definisce la funzione densità di probabilità:

che comporta la seguente affermazione:

ossia la funzione densità di probabilità è la derivata della funzione distribuzione di probabilità o detto alla stessa maniera, la funzione distribuzione è l’integrale della funzione densità in un determinato intervallo.

Per chiarire immediatamente il concetto la funzione densità di probabilità più usata e conosciuta è la distribuzione di Gauss che descrive fenomeni aleatori continui che si concentrano verso un valore più probabile centrale.

La sua equazione è:

la forma della campana e il suo valore centrale dipendono dalla deviazione standard e dalla media .

Eccone un suo grafico:

Per capire la probabilità che una misura cada in un certo intervallo si deve calcolare l’area sottesa dalla curva in quell’intervallo ossia la sua funzione distribuzione o funzione primitiva negli intervalli presi in esame.[:]

[:it]La crittografia a chiave simmetrica utilizza la tessa chiave per cifrare e decifrare il messaggio.

Il cifrario a sostituzione è un esempio di crittografia a chiave simmetrica.

Un esempio di codifica e decodifica, utilizzando gli operatori logici è dato dalla codifica mediante una chiave ed effettuare un XOR sul messaggio di partenza, quindi effettuando un XOR mediante la stessa chiave sul messaggio trasmesso, ho il messaggio inviato ossia:

mi fornisce il messaggio codificato

quindi

Per comprendere adesso l’esempio consiglio di rivedere questi tre post

• operatori logici
• approfondimenti sugli operatori logici
• esercizi sugli operatori logici

Ad esempio invio il seguente messaggio:

Utilizzo la seguente chiave conosciuta sia dal mittente che dal destinatario:

Effettuo XOR tra il messaggio inviato e quello ricevuto ed ho trasmesso il seguente messaggio:

Adesso effettuo nuovamente XOR tra quest’ultimo e la chiave:

Il messaggio decifrato risulta quindi:

Approfondimenti

Più grande è la chiave più prove si devono effettuare per trovare il messaggio inviato.

Il numero di chiavi è sempre la disposizione con ripetizione ossia il numero di chiavi diverse è:

con il numero di bit della chiave.

Una persona che vuole decifrare il messaggio dovrà effettuare un numero esponenziale di prove.

Ad esempio:

• si usi una chiave lunga 40 bit
• si avranno chiavi diverse ossia circa chiavi diverse
• si supponga che si provi una chiave ogni millisecondo ossia secondi
• si pensi per capire l’operazione successiva al seguente esempio ossia si devono lavare tre auto e per ogni auto ci si impiega 10 minuti allora il tempo complessivo sarà , per lavare tre auto ci si impiega 30 minuti.
• applicando nel nostro caso si ha sapendo che in un giorno ci sono 86.400 secondi, dividendo la cifra con il numero di secondi risulta 11’574 giorni.
• supponiamo adesso di utilizzare un PC che provi chiavi in un secondo, esso impiegherà secondi ossia meno di tre ore per trovare la chiave.

Per determinare una chiave abbastanza sicura si usano infatti chiavi lunghe 128 bit.

I sistemi di crittografia a chiave simmetrica sono:

DES: Data Encryption Standard–> IBM 1977 utilizza un chiave a 56 bit (libro di approfondimento sul des)

Triple DES o 3 DES una chiave maggiore

CAST –> Nortel chiave a 128 bit

IDEA International Data Encryption Algorithm–> nel 1990 chiave a 128 bit[:]

[:it]

1. Costruire la tabella della verità associata al seguente circuito logico:

2. Costruire la tabella della verità associata al seguente circuito:

3. Esercizi molto più complesso, associare la tabella di verità al seguente circuito:

 [:]

[:it]Gli operatori logici si possono rappresentare con la seguente rappresentazione grafica:

Tutte le operazioni booleane possono essere ottenute mediante la corretta combinazione delle porte logiche AND, OR e NOT.

Ad esempio un NAND può essere realizzato mediante un AND ed un NOT nella seguente maniera:

Un NOR può essere realizzato mediante un OR ed un NOT nella seguente maniera

Un XOR si può realizzare con un’opportuna combinazione di AND, OR a NOT nella seguente maniera:

[:]

[:it]Completare il seguente CPM con tutte le date per ogni nodo identificando il percorso critico.

In particolare evidenziare il ES,EF, LS,LF ed il TF per tutti i nodi.

[:]

[:it]

roger de la fresnaye

Si richiedano tre numeri 6,7; 87,9;6,87 e successivamente altri tre  5,7; 9,2; 3,4 e che si mettano esattamente con questa sequenza e si trovi il più piccolo, il più grande e la media di ciascuna serie.

Poi si calcoli il prodotto della media e il prodotto dell’errore che viene dato dalla differenza tra il massimo ed il minimo.

Specifiche di programmazione e relativo punteggio:

[:]

[: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;
}[:]