lunedì 8 dicembre 2014

ESERCIZIO PER CASA

Esercitazione

Richiesta per Casa:

Dato il seguente programma presentato a lezione, svolgere i seguenti compiti:
  1. Creare con AlgoBuild i Diagrammi di Flusso delle singole funzioni trasformandole in main singoli
  2. Modificare il costrutto switch case con i necessari costrutti if
  3. Pubblicare sul proprio Blog Algoritmi delle Funzioni e Diagrammi di flusso
  4. Comunicare l'avvenuta pubblicazione al docente con eMail ed aggiungere il link del post
  5. Aprire un progetto in DevCpp
  6. Creare l'Header con tutti i prototipi delle funzioni separati da virgola e chiamatelo FattPotPriMenu.h
  7. Creare il File FattPotPriMenu.cpp con tutte le definizioni delle Funzioni
  8. Create un file per il main chiamato mainFattPotPriMenu.cpp includendo l'Header FattPotPriMenu.h
  9. Salvate l'intero Progetto
  10. Compilate l'intero Progetto
  11. Acquisire le schermate DOS del Menu e dei risultati delle singole chiamate e pubblicatele sul Blog  e ripetete il punto 4)

Presenta ciclicamente un menù, fino a quando non si digita x, per scegliere una delle seguenti opzioni:

   a) Fattoriale di un numero (<=12)
   b) Numeri primi fino a N
   c) Potenza N-esima (N>=0 intero) di un numero reale A (!=0)
   x) Fine

Vediamo ora il Codice su cui lavorare:



Inziamo ora a scomporre il programma in sottoprogrammi e rappresentando le singole funzioni con il diagramma di flusso fatto con Algobuild:

FUNZIONE MENU:

char menu()
{char s;
 do
  {system ("cls");
   cout<<"\n                           MENU\n"<<endl;
   cout<<"  a)  Fattoriale di un numero (<=12)"<<endl;
   cout<<"  b)  Numeri primi fino a N"<<endl;
   cout<<"  c)  Potenza N-esima (N>=0 intero) di un numero reale A (!=0)"<<endl;
   cout<<"  x)  Fine"<<endl;
   cout<<"\nScegli: ";
   cin>>s;
   }while (s!='a' && s!='b' && s!='c' && s!='x');
  return s;
}





Questa funzione restituisce un carattere A o B o C o X.

FUNZIONE FATTORIALE:

unsigned int Fattoriale(int N)
{ unsigned int F = 1;  
  for (int i = 2; i <= N; i++)
     F = F * i;
  return F;  
}




Questa funzione riceve in ingresso un numero intero e restituisce un numero intero senza segno.

FUNZIONE NUMERI PRIMI FINO A N:

void NumeriPrimi(int N)
{
 for (int i = 2; i <= N; i++)
      if (ControlloNumeroPrimo(i)==true)  // richiama la funzione  ControlloNumeroPrimo
             cout << i << ";  ";
      cout << endl;
 return;
}




Questa funzione riceve in input un numero intero e non restituisce nulla. Al suo interno viene effettuata una chiamata alla funzione ControlloNumeroPrimo.


FUNZIONE CONTROLLONUMEROPRIMO:

bool ControlloNumeroPrimo(int N) 
{// Controllo se il numero e' minore o uguale a 1:
 // numero non primo, uscita immediata  e   restituisce false.
 if (N <= 1) return false; 
 // Sfrutta direttamente la definizione di numero primo:
 // provo a dividere N  per tutti i numeri da 2 a N/2;
 // se almeno una divisione ha resto nullo (divisibilità)
 //      allora il numero NON E' PRIMO, uscita immediata e restituisce FALSE.
 // se nessuna divisione ha resto nullo allora il numero  E' PRIMO  e restituisce TRUE.
 for (int i = 2; i <= N/2; i++)
       if (N % i == 0) return false;
 return true;
}




Questa funzione riceve in input un numero intero e restituisce il valore TRUE o FALSE.
TRUE=1 e FALSE=0.

FUNZIONE POTENZA:

float Potenza(float base, int esponente)
{  // Funzione che calcola base elevata a esponente
   float Pot = 1; // Inizializza la variabile accumulatore
   for(int i = 1; i <=esponente; i++)
       Pot = Pot * base;
   return Pot;
}




Questa Funzione riceve in input un numero con la virgola di tipo float per la base e un numero intero per l'esponente e restituisce un numero con la virgola di tipo float.

Infine ecco le immagini catturate di ciò che farà il programma:

Menu:


Programma per il calcolo del Fattoriale:

Programma che visualizza i numeri primi fino al numero scelto:

Programma che calcola la potenza N-esima di un numero reale:

Uscita premendo la X:

Fine esercizio.

domenica 9 novembre 2014

ESER. INFORMATICA - ESERCIZIO 5

ESERCIZIO 5

Si supponga che 3 dispositivi trasferiscano dati rispettivamente ad una velocità di 6 Gbit/s, 3Gbit/sec e 1,5 Gbit al secondo, calcolare per ciascun dispositivo il tempo necessario per eseguire il backup di un hdd da 500 GByte e di un Hdd da 1 TByte.

Parto sempre dal considerare che 1 byte=8 bit e quindi :

6 Gbit/sec = 0,75 GByte/sec;
3 Gbit/sec = 0,375 GByte/sec;
1,5 Gbit/sec = 0,1875 GByte/sec;

Quindi mi basterà dividere la capacità dei dispositivi per la velocità di trasferimento per trovare il tempo necessario a riempire i 2 Hard Disk.
Userò un ciclo che si ripeterà e ogni volta dimezzerà la velocità.

Hdd da 500 gb;

6 Gbit/sec = 500 / (6/8) = 666 secondi = 11 minuti e 6 secondi ;
3 Gbit/sec = 500 / (3/8) = 1333 secondi = 22 minuti e 13 secondi ;
1,5 Gbit/sec = 500 / (1,5/8) = 2666 secondi = 44 minuti e 26 secondi .

Hdd da 1 TB;

Considerato che 1 GByte=2^30 e che 1TB=2^40 ;

6 Gbit/sec = (1*2^40) / (6/8*2^30) = 1365 secondi = 22 minuti e 45 secondi ;
3 Gbit/sec = (1*2^40) / (3/8*2^30) = 2730 secondi = 45 minuti e 30 secondi ;
1,5 Gbit/sec = (1*2^40) / (1,5/8*2^30) = 5461 secondi = 1 ora 31 minuti 1 secondo .

L’esercizio non richiede l’inserimento di dati dall’utento o la generazione di numeri casuali ma assegna velocità stabilite e dimensioni stabilite. Il risultato dell’operazione sarà espressa in secondi e quindi poi passerò alla trasformazione in ore, minuti e secondi.

Variabili:

L’esercizio non richiede l’inserimento di dati dall’utente o di generare numeri casuali ma i valori sono prestabiliti quindi come input userò la variabile che contiene la velocità e saràdi tipo float in quanto saranno valori con la virgola.
Userò il tipo intero per tutte le altre variabili perché i decimali dei secondi non mi sevono.

velocita : di tipo float (a cui assegnerò di volta in volta la velocità per il calcolo); Input;
i : di tipo float (che userò come contatore che mi permetterò di uscire dal ciclo); Lavoro ;
hdd : di tipo int  (a cui assegno i risultati dei secondi totali per gli HDD); lavoro;
mintot : di tipo int (che userò per calcolare il resto dei minuti e le ore); lavoro;
ore : di tipo int (che uso per stampare le ore); output;
minuti: di tipo int (che uso per stampare i minuti); output;
secondi : di tipo int (che uso per stampare le ore); output;

Strumenti:

divisione;
moltiplicazione;
modulo;
pow;


Bozza Programma:

int mintot,ore,minuti,secondi,hdd,i;
float velocita;
           
i=1;
velocita=6;
printf(“Per fare un backup di un disco da 500 Gb occorrono : \n\n”);
do
{
hdd=500/(velocita/8);
secondi=hdd%60;
mintot=hdd/60;
minuti=mintot%60;
ore=mintot/60;
printf ("%d ore : %d minuti : %d secondi - Alla velocita' di %.2f Gbit/sec \n" ,ore,minuti,secondi,velocita);
i++;
velocita=velocita/2;
}          
while (i<=3);
i=1;
velocita=6;
printf("\n\nPer fare un backup di un disco da 1 TByte occorrono : \n\n");
do
{
hdd=(1*pow(2,40))/(velocita/8*pow(2,30));
secondi=hdd%60;
mintot=hdd/60;
minuti=mintot%60;
ore=mintot/60;
printf ("%d ore : %d minuti : %d secondi - Alla velocita' di %.2f Gbit/sec \n", ore,minuti,secondi,velocita);
i++;
velocita=velocita/2;
}
while (i<=3);


Codifica in linguaggio C:

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

int main ()

{
            int mintot,ore,minuti,secondi,hdd,i;
            float velocita;
           
            i=1; // variaile per il controllo di uscita dal ciclo
            velocita=6; // parto dai 6 Gbit all secondo
           
            printf("Per fare un backup di un disco da 500 Gb occorrono : \n\n");

            do
                        {
                                   hdd=500/(velocita/8);
                                   secondi=hdd%60;
                                   mintot=hdd/60;
                                   minuti=mintot%60;
                                   ore=mintot/60;
                                   printf ("%d ore : %d minuti : %d secondi - Alla velocita' di %.2f Gbit/sec \n", ore,minuti,secondi,velocita);
                                   i++;
                                   velocita=velocita/2;
                        }         
            while (i<=3); // il ciclo si ripete fino a quando i è minore o uguale a 3

            i=1; //reimposto il contatore per il ciclo a 1
            velocita=6; // reimposto la velocita a 6 gbit/sec
            printf("\n\nPer fare un backup di un disco da 1 TByte occorrono : \n\n");

            do
                        {
                                   hdd=(1*pow(2,40))/(velocita/8*pow(2,30));
                                   secondi=hdd%60;
                                   mintot=hdd/60;
                                   minuti=mintot%60;
                                   ore=mintot/60;
                                   printf ("%d ore : %d minuti : %d secondi - Alla velocita' di %.2f Gbit/sec \n", ore,minuti,secondi,velocita);
                                   i++;
                                   velocita=velocita/2;
                        }
            while (i<=3);
                       
            return 0;
}



Diagramma di Flusso (Algobuild):


ESER. INFORMATICA - ESERCIZIO 4

ESERCIZIO 4

Si supponga che un dispositivo trasferisca dati ad una velocità di 10 MBIT/sec calcolare il tempo necessario per trasferire il contenuto di un CD di un DVD e di un Blue Ray.

Prima di tutto recupero le capacità dei supporti:

CD-ROM = 700 MByte;
DVD = 4,7 GByte;
Blu-Ray = 25 GByte.

Considerato che : 1 byte = 8 bit -> 10 Mbit/sec = 1,25 Mbyte/sec e che 1 MByte=2^20 e che 1 GByte= 2^30;
non devo far altro che dividere la capacità dei tre supporti per la velocità in Mbyte/sec e quindi;

CD-ROM 700 Mbyte = (700*2^20) / (1,25*2^20) = 560 secondi = 9 minuti e 20 secondi ;

DVD = 4,7 GByte = (4,7*2^30) / (1,25*2^20) = 3,76*2^10= 3850 secondi = 1 ora 4 minuti e 10 secondi;

Blu-ray = 25 GByte = (25*2^30) / (1,25*2^20) = 20*2^10 = 20480 secondi = 5 ore 41 minuti 20 secondi;

Troverò prima i secondi totali e poi passerò al calcolo delle ore, minuti e secondi.

Variabili :

L'esercizio non richiede l'inserimento di un dato dall'utente o la generazione di un numero casuale ma assegna una velocità e una dimensione prestabiliti. Non utilizzerò quindi variabili di input ma solo di lavoro e di output. Userò solo variabili di tipo intero perché i decimali dei secondi non mi servono.

cdrom – di tipo int  (a cui assegno i secondi necessari a riepirlo); variabile di lavoro;
dvd – di tipo int (a cui assegno i secondi necessari a riempirlo); variabile di lavoro;
bluray – di tipo int (a cui assegno i secondi necessari a riempirlo); variabile di lavoro;
mintot – di tipo int (che utlizzo per trovare le ore e i minuti residui); variabile di lavoro;
ore – di tipo int (che utlizzo per la stampa in output delle ore); variabile di output;
minuti – di tipo int (che utilizzo per la stampa in output dei munuti); variabile di output;
secondi – di tipo int (che utlizzo per la stampa in output dei secondi); variabile di output;

Strumenti:

divisione;
moltiplicazione;
modulo;
pow(2,20);

Bozza programma:

int mintot,ore,minuti,secondi,cdrom,dvd,bluray;

cdrom=700 / 1,25;
dvd=(4.7*pow(2,30)) / (1.25*pow(2,20));
bluray=(25*pow(2,30)) / (1.25*pow(2,20));

secondi=cdrom%60;
mintot=cdrom/60;
minuti=mintot%60;
printf("%d minuti : %d secondi ci vogliono per riempire un CD da 700 MByte \n\n", minuti,secondi);

secondi=dvd%60;
mintot=dvd/60;
minuti=mintot%60;
ore=mintot/60;
printf("%d ore : %d minuti : %d secondi ci vogliono per riempire un DVD da 4,7 GByte \n\n", ore,minuti,secondi);
           
secondi=bluray%60;
mintot=bluray/60;
minuti=mintot%60;
ore=mintot/60;
printf("%d ore : %d minuti : %d secondi ci vogliono per riempire un Bluray da 25 GByte \n\n", ore,minuti,secondi);


Codifica in Linguaggio C:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main()

{
            int mintot,ore,minuti,secondi,cdrom,dvd,bluray;
                                                          
            //qui faccio le operazioni e trovo i secondi totali necessari a riempire i supporti
            cdrom=700/1.25;
            dvd=(4.7*pow(2,30))/(1.25*pow(2,20));
            bluray=(25*pow(2,30))/(1.25*pow(2,20));
           
            printf("Alla velocita' di trasferimento di 10Mbit/sec ci vogliono : \n\n");
           
            // qui faccio la procedura per calcolare il tempo del CDrom         in minuti e secondi
            secondi=cdrom%60;
            mintot=cdrom/60;
            minuti=mintot%60;
           
            printf("%d minuti : %d secondi per riempire un CD da 700 MByte \n\n", minuti,secondi);
           
            // qui faccio la procedura per calcolare il tempo del DVD in ore,minuti e secondi
            secondi=dvd%60;
            mintot=dvd/60;
            minuti=mintot%60;
            ore=mintot/60;
            printf("%d ore : %d minuti : %d secondi per riempire un DVD da 4,7 GByte \n\n", ore,minuti,secondi);
           
            // qui faccio la procedura per calcolare il tempo del Bluray in ore,minuti e secondi
            secondi=bluray%60;
            mintot=bluray/60;
            minuti=mintot%60;
            ore=mintot/60;
            printf("%d ore : %d minuti : %d secondi per riempire un Bluray da 25 GByte \n\n", ore,minuti,secondi);
            return 0;        
                       

}


Diagramma di Flusso (Algobuild):