API tools faq
paste
Advertisement
Guest User

Convertitore in C

a guest
Oct 19th, 2013
35
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 36.46 KB | None | 0 0
raw download clone embed print report
  1. /* Convertitore by Çlÿkÿ~ */
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <math.h>
  6.  
  7. int main()
  8.  
  9. {
  10. /* Variabili */
  11. int unita_misura_da_convertire; /* unità di misura attuale */
  12. int risultato_unita_misura; /* unità di misura scelta dall'utente nella quale si desidera convertire il numero iniziale */
  13. int unita_misura_variabile; /* numero usato nel calcolo per stabilire l'esponente della potenza */
  14. int scelta_iniziale; /* scegliere su quale unità di misura si desidera lavorare (1 = peso; 2 = lunghezza; 3 = capacità) */
  15. int scelta_scelta_3; /* scegliere se fare il calcolo coi metri cubi o coi litri */
  16.  
  17. float parte_numerica; /* parte numerica inserita inizialmente */
  18. float risultato_parte_num; /* risultato parte numerica */
  19.  
  20. char scelta_ripetizione_totale; /* per decidere se ripetere TUTTO il programma */
  21. char scelta_volume; /* per sapere se si vuole tenere l'unità in litri o convertirla in metri cubi */
  22. char scelta_m_cubi_o_litri; /* quando si scelgono i metri cubi, decidere se restare nei metri cubi o se passare da metri cubi a litri */
  23.  
  24. /* Programma */
  25.  
  26. /* Scelta iniziale (su quale unità di misura si desidera lavorare) */
  27.  
  28.     do /* inizio do per la ripetizione del programma */
  29.     {
  30.         system("cls");
  31.        
  32.         do /* inizio do per la ripetizione se l'inserimento è errato */
  33.         {
  34.             printf("\t \t %c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c \n", 201, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 187);
  35.             printf("\t \t %c Ciao! \t \t \t \t \t  %c \n", 186, 186);
  36.             printf("\t \t %c Posso convertirti vari numeri in ci%c che vuoi. %c \n", 186, 149, 186);
  37.             printf("\t \t %c In quale ambito vuoi lavorare? \t \t  %c \n", 186, 186);
  38.             printf("\t \t %c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c \n \n", 200, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 188);
  39.  
  40.  
  41.             printf("1. Peso (Kg) \n");
  42.             printf("2. Lunghezza (m) \n");
  43.             printf("3. Volume (L) \n");
  44.             printf("4. Superficie (m quad.) \n");
  45.             printf("5. Temperatura (K) \n");
  46.             printf("6. Tempo (s) \n");
  47.             printf("7. Memoria virtuale (B) \n");
  48.             printf("8. Velocit%c (m/s) \n \n", 133);
  49.  
  50.             printf("Digita il numero corrispondente qui: ");
  51.             scanf("%i",&scelta_iniziale);
  52.             fflush(stdin);
  53.             printf("\n");
  54.  
  55.             if((scelta_iniziale < 1) || (scelta_iniziale > 8))
  56.             {
  57.                 printf("Hai inserito un valore non consentito. \n");
  58.                 printf("Puoi inserire solo valori dall'1 al 3. \n \n");
  59.             } /* fine if */
  60.         } /* fine do iniziale (ripeti se l'inserimento è errato) */
  61.         while(scelta_iniziale < 1 || scelta_iniziale > 8);
  62.  
  63.         /* Peso */
  64.  
  65.         if(scelta_iniziale == 1) /* inizio if se si sceglie di lavorare sul peso */
  66.         {
  67.             printf("Inserisci la misura indicandone l'unit%c: \n \n", 133);
  68.  
  69.             printf("1. Tonnellate (t) \n");
  70.             printf("2. Quintali (q) \n");
  71.             printf("3. Kilogrammi (Kg) \n");
  72.             printf("4. Ettogrammi (hg) \n");
  73.             printf("5. Decagrammi (dag) \n");
  74.             printf("6. Grammi (g) \n");
  75.             printf("7. Decigrammi (dg) \n");
  76.             printf("8. Centigrammi (cg) \n");
  77.             printf("9. Milligrammi (mg) \n \n");
  78.  
  79.             printf("Digita la parte numerica della misura: ");
  80.             scanf("%f",&parte_numerica);
  81.             fflush(stdin);
  82.             printf("\n");
  83.  
  84.             do  /* ripetere in caso sia errato l'inserimento (numero minore di 1 o maggiore di 9) */
  85.             {
  86.                 printf("Seguendo la tabella di prima, digita il numero corrispondente all'unit%c di misura: ", 133);
  87.                 scanf("%i",&unita_misura_da_convertire);
  88.                 fflush(stdin);
  89.                 printf("\n");
  90.            
  91.                 printf("Sempre seguendo la tabella precedente, indica quale misura vuoi ottenere: ");
  92.                 scanf("%i",&risultato_unita_misura);
  93.                 fflush(stdin);
  94.                 printf("\n");
  95.  
  96.                 if((unita_misura_da_convertire < 1) || (unita_misura_da_convertire > 9) || (risultato_unita_misura < 1) || (unita_misura_da_convertire > 9)) /* if per determinare se l'inserimento è fallito */
  97.                 {
  98.                     printf("Inserimento fallito. \n");
  99.                     printf("Puoi inserire soltanto numeri da 1 a 9. \n");
  100.                     printf("Riprova. \n \n");
  101.                 }   /* termine if */
  102.  
  103.                 if(unita_misura_da_convertire == risultato_unita_misura) /* if per determinare se l'unità inserita per prima e quella inserita per seconda sono uguali */
  104.                 {
  105.                     printf("Inserimento fallito. \n");
  106.                     printf("Le due unita' da te inserite sono uguali. \n");
  107.                     printf("Riprova. \n \n");
  108.                 }   /* termine if */
  109.             }   /* termine do per la ripetizione in caso di inserimento fallito */
  110.             while((unita_misura_da_convertire < 1) || (unita_misura_da_convertire > 9) || (risultato_unita_misura < 1) || (unita_misura_da_convertire > 9) || (unita_misura_da_convertire == risultato_unita_misura));
  111.  
  112.             /* Calcolo (peso) */
  113.  
  114.             if(unita_misura_da_convertire < risultato_unita_misura)
  115.             {
  116.                 unita_misura_variabile = risultato_unita_misura - unita_misura_da_convertire;
  117.             }
  118.             else
  119.                 if(unita_misura_da_convertire > risultato_unita_misura)
  120.                 {
  121.                     unita_misura_variabile = unita_misura_da_convertire - risultato_unita_misura;
  122.                 }
  123.  
  124.             if(unita_misura_da_convertire < risultato_unita_misura)
  125.             {
  126.                 risultato_parte_num = (parte_numerica * pow(10, unita_misura_variabile));
  127.             }
  128.             else
  129.                 if(unita_misura_da_convertire > risultato_unita_misura)
  130.                 {
  131.                     risultato_parte_num = (parte_numerica / pow(10, unita_misura_variabile));
  132.                 }
  133.  
  134.             printf("La parte numerica risulta %.3f \n", risultato_parte_num);
  135.         } /* termine if del peso */
  136.  
  137.         if(scelta_iniziale == 2) /* inizio if se si sceglie di lavorare sulle lunghezze */
  138.         {
  139.             printf("Inserisci la misura indicandone l'unit%c: \n \n", 133);
  140.  
  141.             printf("1. Kilometri (Km) \n");
  142.             printf("2. Ettometri (h) \n");
  143.             printf("3. Decametri (Dam) \n");
  144.             printf("4. Metri (m) \n");
  145.             printf("5. Decimetri (dm) \n");
  146.             printf("6. Centimetri (cm) \n");
  147.             printf("7. Millimetri (mm) \n \n");
  148.  
  149.             printf("Digita la parte numerica della misura: ");
  150.             scanf("%f",&parte_numerica);
  151.             fflush(stdin);
  152.             printf("\n");
  153.  
  154.             do  /* ripetere in caso sia errato l'inserimento (numero minore di 1 o maggiore di 7) */
  155.             {
  156.                 printf("Seguendo la tabella di prima, digita il numero corrispondente all'unit%c di misura: ", 133);
  157.                 scanf("%i",&unita_misura_da_convertire);
  158.                 fflush(stdin);
  159.                 printf("\n");
  160.            
  161.                 printf("Sempre seguendo la tabella precedente, indica quale misura vuoi ottenere: ");
  162.                 scanf("%i",&risultato_unita_misura);
  163.                 fflush(stdin);
  164.                 printf("\n");
  165.  
  166.                 if((unita_misura_da_convertire < 1) || (unita_misura_da_convertire > 7) || (risultato_unita_misura < 1) || (unita_misura_da_convertire > 7))
  167.                 {
  168.                     printf("Inserimento fallito. \n");
  169.                     printf("Puoi inserire soltanto numeri da 1 a 7. \n");
  170.                     printf("Riprova. \n \n");
  171.                 }
  172.  
  173.                 if(unita_misura_da_convertire == risultato_unita_misura) /* if per determinare se l'unità inserita per prima e quella inserita per seconda sono uguali */
  174.                 {
  175.                     printf("Inserimento fallito. \n");
  176.                     printf("Le due unita' da te inserite sono uguali. \n");
  177.                     printf("Riprova. \n \n");
  178.                 }   /* termine if */
  179.             }
  180.             while(((unita_misura_da_convertire < 1) || (unita_misura_da_convertire > 7)) || (risultato_unita_misura < 1) || (unita_misura_da_convertire > 7) || (unita_misura_da_convertire == risultato_unita_misura));
  181.  
  182.             /* Calcolo (lunghezza) */
  183.  
  184.             if(unita_misura_da_convertire < risultato_unita_misura) /* cosa fare se il numero dell'unità indicata inizialmente è minore rispetto a quello indicato dopo */
  185.             {
  186.                 unita_misura_variabile = risultato_unita_misura - unita_misura_da_convertire;
  187.             } /* fine if */
  188.             else
  189.                 if(unita_misura_da_convertire > risultato_unita_misura) /* cosa fare se il numero dell'unità indicata inizialmente è maggiore rispetto a quello indicato dopo */
  190.                 {
  191.                     unita_misura_variabile = unita_misura_da_convertire - risultato_unita_misura;
  192.                 }   /* fine if */
  193.  
  194.             if(unita_misura_da_convertire < risultato_unita_misura) /* se l'unità di misura inserita prima è minore rispetto a quella inserita dopo, moltiplicare il risultato */
  195.             {
  196.                 risultato_parte_num = (parte_numerica * pow(10, unita_misura_variabile));
  197.             } /* fine if */
  198.             else
  199.                 if(unita_misura_da_convertire > risultato_unita_misura) /* se l'unità di misura inserita prima è maggiore rispetto a quella inserita dopo, dividere il risultato */
  200.                 {
  201.                     risultato_parte_num = (parte_numerica / pow(10, unita_misura_variabile));
  202.                 }
  203.  
  204.             printf("La parte numerica risulta %.3f \n \n", risultato_parte_num);
  205.         } /* termine if della lunghezza */
  206.  
  207.         if(scelta_iniziale == 3) /* inizio if se si sceglie di lavorare sul volume */
  208.         {
  209.             printf("Scegli quale unit%c di misura vuoi usare: \n \n", 133);
  210.            
  211.             printf("1. Metri cubi (m%c) \n", 252);
  212.             printf("2. Litri (L) \n \n");
  213.  
  214.             do
  215.             {
  216.                 printf("Inserisci il numero corrispondente qui: ");
  217.                 scanf("%i",&scelta_scelta_3);
  218.                 fflush(stdin);
  219.                 printf("\n");
  220.  
  221.                 if(scelta_scelta_3 != 1 && scelta_scelta_3 != 2)
  222.                 {
  223.                     printf("Inserimento fallito. \n");
  224.                     printf("Puoi inserire solo 1 e 2. \n");
  225.                     printf("Riprova. \n \n");
  226.                 }
  227.             }
  228.             while(scelta_scelta_3 != 1 && scelta_scelta_3 != 2);
  229.  
  230.             if(scelta_scelta_3 == 1)
  231.             {
  232.                 printf("Inserisci la misura indicandone l'unit%c: \n \n", 133);
  233.  
  234.                 printf("1. Metri cubi (m%c) \n", 252);
  235.                 printf("2. Decimetri cubi (dm%c) \n", 252);
  236.                 printf("3. Centimetri cubi (cm%c) \n \n", 252);
  237.  
  238.                 printf("Digita la parte numerica della misura: ");
  239.                 scanf("%f",&parte_numerica);
  240.                 fflush(stdin);
  241.                 printf("\n");
  242.  
  243.                 do
  244.                 {
  245.                     printf("Seguendo la tabella di prima, digita il numero corrispondente all'unit%c di misura: ", 133);
  246.                     scanf("%i",&unita_misura_da_convertire);
  247.                     fflush(stdin);
  248.                     printf("\n");
  249.  
  250.                     if(unita_misura_da_convertire < 1 || unita_misura_da_convertire > 3)
  251.                     {
  252.                         printf("Inserimento fallito. \n");
  253.                         printf("Puoi inserire soltanto numeri da 1 a 3. \n");
  254.                         printf("Riprova. \n \n");
  255.                     }
  256.                 }
  257.                 while(unita_misura_da_convertire < 1 || unita_misura_da_convertire > 3);
  258.  
  259.                 do
  260.                 {
  261.                     printf("Vuoi rimanere nei metri cubi o passare ai litri? \n");
  262.                     printf("Premi 'm' per restare nei metri cubi, 'L' per passare ai litri. ");
  263.                     fflush(stdin);
  264.                     scanf("%c",&scelta_m_cubi_o_litri);
  265.                     printf("\n");
  266.  
  267.                     if(scelta_m_cubi_o_litri != 'm' && scelta_m_cubi_o_litri != 'M' && scelta_m_cubi_o_litri != 'l' && scelta_m_cubi_o_litri != 'L')
  268.                     {
  269.                         printf("Inserimento fallito. \n");
  270.                         printf("Puoi inserire soltanto l, L, m ed M. \n");
  271.                         printf("Riprova. \n \n");
  272.                     }
  273.                 }
  274.                 while(scelta_m_cubi_o_litri != 'm' && scelta_m_cubi_o_litri != 'M' && scelta_m_cubi_o_litri != 'l' && scelta_m_cubi_o_litri != 'L');
  275.  
  276.                 if(scelta_m_cubi_o_litri == 'm' || scelta_m_cubi_o_litri == 'M');
  277.                 {
  278.                     do
  279.                     {
  280.                         printf("Seguendo la tabella di prima, digita il numero corrispondente all'unit%c di misura che vuoi ottenere: ", 133);
  281.                         scanf("%i",&risultato_unita_misura);
  282.                         fflush(stdin);
  283.                         printf("\n");
  284.  
  285.                         if(unita_misura_da_convertire == risultato_unita_misura)
  286.                         {
  287.                             printf("Inserimento fallito. \n");
  288.                             printf("Le due unit%c di misura sono uguali.", 133);
  289.                             printf("Riprova. \n \n");
  290.                         }
  291.                     }
  292.                     while(unita_misura_da_convertire == risultato_unita_misura);
  293.  
  294.                     /* Calcolo volume - metri cubi a metri cubi */
  295.  
  296.                     if(unita_misura_da_convertire < risultato_unita_misura)
  297.                     {
  298.                         unita_misura_variabile = risultato_unita_misura - unita_misura_da_convertire;
  299.                     }
  300.                     else
  301.                         if(unita_misura_da_convertire > risultato_unita_misura)
  302.                         {
  303.                             unita_misura_variabile = unita_misura_da_convertire - risultato_unita_misura;
  304.                         }
  305.  
  306.                     if(unita_misura_da_convertire > risultato_unita_misura)
  307.                     {
  308.                         risultato_parte_num = parte_numerica / pow(1000, unita_misura_variabile);
  309.                     }
  310.                     else
  311.                         if(unita_misura_da_convertire < risultato_unita_misura)
  312.                         {
  313.                             risultato_parte_num = parte_numerica * pow(1000, unita_misura_variabile);
  314.                         }
  315.  
  316.                     printf("La parte numerica risulta %.3f \n \n", risultato_parte_num);
  317.                 } /* fine per calcolare metri cubi a metri cubi */
  318.  
  319.                 if(scelta_m_cubi_o_litri == 'l' || scelta_m_cubi_o_litri == 'L')
  320.                 {
  321.                     printf("Inserisci quale unit%c di misura vuoi ottenere: \n \n", 133);
  322.  
  323.                     printf("4. Kilolitri (KL) \n");
  324.                     printf("5. Ettolitri (HL) \n");
  325.                     printf("6. Decalitri (daL) \n");
  326.                     printf("7. Litri (L) \n");
  327.                     printf("8. Decilitri (dL) \n");
  328.                     printf("9. Centilitri (cL) \n");
  329.                     printf("10. Millilitri (mL) \n \n");
  330.  
  331.                     do
  332.                     {
  333.                         printf("Digita il numero di seguito: ");
  334.                         scanf("%i",&risultato_unita_misura);
  335.                         fflush(stdin);
  336.                         printf("\n");
  337.  
  338.                         if(risultato_unita_misura < 4 || risultato_unita_misura > 10)
  339.                         {
  340.                             printf("Inserimento fallito. \n");
  341.                             printf("Puoi inserire soltanto numeri da 4 a 10. \n");
  342.                             printf("Riprova. \n \n");
  343.                         }
  344.                     }
  345.                     while(risultato_unita_misura < 4 || risultato_unita_misura > 10);
  346.  
  347.                     if((unita_misura_da_convertire == 1 && risultato_unita_misura == 4) || (unita_misura_da_convertire == 2 && risultato_unita_misura == 7) || (unita_misura_da_convertire == 3 && risultato_unita_misura == 10))
  348.                     {
  349.                         risultato_parte_num = parte_numerica;
  350.                     }
  351.  
  352.                     if(unita_misura_da_convertire == 1)
  353.                     {
  354.                         unita_misura_variabile = risultato_unita_misura - 4;
  355.                         risultato_parte_num = parte_numerica * pow(10, unita_misura_variabile);
  356.                     }
  357.                     else
  358.                         if(unita_misura_da_convertire == 2)
  359.                         {
  360.                             unita_misura_variabile = risultato_unita_misura - 7;
  361.                             risultato_parte_num = parte_numerica * pow(10, unita_misura_variabile);
  362.                         }
  363.                         else
  364.                             if(unita_misura_da_convertire == 3)
  365.                             {
  366.                                 unita_misura_variabile = risultato_unita_misura - 10;
  367.                                 risultato_parte_num = parte_numerica * pow(10, unita_misura_variabile);
  368.                             }
  369.  
  370.                     printf("La parte numerica risulta %.3f. \n \n");
  371.                 } /* termine if metri cubi a litri */
  372.             } /* fine scelta dei metri cubi */
  373.  
  374.             if(scelta_scelta_3 == 2)
  375.             {
  376.                 printf("Inserisci la misura indicandone l'unit%c: \n \n", 133);
  377.                
  378.                 printf("1. Kilolitri (KL) \n");
  379.                 printf("2. Ettolitri (hL) \n");
  380.                 printf("3. Decalitri (DaL) \n");
  381.                 printf("4. Litri (L) \n");
  382.                 printf("5. Decilitri (dL) \n");
  383.                 printf("6. Centilitri (cL) \n");
  384.                 printf("7. Millilitri (mL) \n \n");
  385.  
  386.                 printf("Digita la parte numerica della misura: ");
  387.                 scanf("%f",&parte_numerica);
  388.                 fflush(stdin);
  389.                 printf("\n");
  390.  
  391.                 do  /* ripetere in caso sia errato l'inserimento (numero minore di 1 o maggiore di 7) */
  392.                 {
  393.                     printf("Seguendo la tabella di prima, digita il numero corrispondente all'unit%c di misura: ", 133);
  394.                     scanf("%i",&unita_misura_da_convertire);
  395.                     fflush(stdin);
  396.                     printf("\n");
  397.                 }
  398.                 while((unita_misura_da_convertire < 1) || (unita_misura_da_convertire > 7));
  399.  
  400.                     do
  401.                     {
  402.                         printf("Ora puoi scegliere se convertirlo in m%c o tenerlo in litri. \n", 252);
  403.                         printf("Premi 'y' se vuoi passare ai m%c, oppure 'n' per tenere i litri. \n", 252);
  404.                         fflush(stdin);
  405.                         scanf("%c",&scelta_volume);
  406.  
  407.                         if(scelta_volume != 'y' || scelta_volume != 'Y' && scelta_volume != 'n' || scelta_volume != 'N')
  408.                         {
  409.                             printf("Inserimento fallito. \n");
  410.                             printf("Puoi inserire solo y, Y, n, N. \n");
  411.                             printf("Riprova. \n \n");
  412.                         }
  413.                     }
  414.                     while(scelta_volume != 'y' || scelta_volume != 'Y' && scelta_volume != 'n' || scelta_volume != 'N');
  415.  
  416.                     if(scelta_volume == 'y' || scelta_volume == 'Y')
  417.                     {
  418.                         printf("Quale unit%c di misura vuoi ottenere? \n \n", 133);
  419.                        
  420.                         printf("8. Metri cubi (m%c) \n", 252);
  421.                         printf("9. Decimetri cubi (dm%c) \n", 252);
  422.                         printf("10. Centimetri cubi (cm%c) \n", 252);
  423.  
  424.                         do
  425.                         {
  426.                             printf("Digita qui il numero corrispondente: ");
  427.                             scanf("%i",&risultato_unita_misura);
  428.                             fflush(stdin);
  429.                             printf("\n");
  430.  
  431.                             if(risultato_unita_misura < 8 || risultato_unita_misura > 10)
  432.                             {
  433.                                 printf("Inserimento fallito. \n");
  434.                                 printf("Puoi inserire solo numeri da 1 a 4. \n");
  435.                                 printf("Riprova. \n \n");
  436.                             }
  437.                         }
  438.                         while(risultato_unita_misura < 8 || risultato_unita_misura > 10);
  439.                    
  440.                         /* Calcolo volume - litri a metri cubi */
  441.  
  442.                         if((unita_misura_da_convertire == 7 && risultato_unita_misura == 10) || (unita_misura_da_convertire == 4 && risultato_unita_misura == 9) || (unita_misura_da_convertire == 1 && risultato_unita_misura == 8))
  443.                         {
  444.                             risultato_parte_num = parte_numerica;
  445.                         }
  446.  
  447.                         if(unita_misura_da_convertire == 1 && risultato_unita_misura == 9) /* se vuole convertire i kilolitri */
  448.                         {
  449.                             risultato_parte_num = parte_numerica * 1000;
  450.                         }
  451.                         else
  452.                             if(unita_misura_da_convertire == 1 && risultato_unita_misura == 10)
  453.                             {
  454.                                 risultato_parte_num = parte_numerica * 1000000;
  455.                             } /* termine kilolitri */
  456.  
  457.                         if(unita_misura_da_convertire == 2 && risultato_unita_misura == 8) /* se vuole convertire gli ettolitri */
  458.                         {
  459.                             risultato_parte_num = parte_numerica / 10;
  460.                         }
  461.                         else
  462.                             if(unita_misura_da_convertire == 2 && risultato_unita_misura == 9)
  463.                             {
  464.                                 risultato_parte_num = parte_numerica * 100;
  465.                             }
  466.                             else
  467.                                 if(unita_misura_da_convertire == 2 && risultato_unita_misura == 10)
  468.                                 {
  469.                                     risultato_parte_num = parte_numerica * 100000;
  470.                                 } /* termine ettolitri */
  471.  
  472.                         if(unita_misura_da_convertire == 3 && risultato_unita_misura == 8) /* se vuole convertire i decalitri */
  473.                         {
  474.                             risultato_parte_num = parte_numerica / 100;
  475.                         }
  476.                         else
  477.                             if(unita_misura_da_convertire == 3 && risultato_unita_misura == 9)
  478.                             {
  479.                                 risultato_parte_num = parte_numerica * 10;
  480.                             }
  481.                             else
  482.                                 if(unita_misura_da_convertire == 3 && risultato_unita_misura == 10)
  483.                                 {
  484.                                     risultato_parte_num = parte_numerica * 10000;
  485.                                 } /* termine decalitri */
  486.                            
  487.                         if(unita_misura_da_convertire == 4 && risultato_unita_misura == 8) /* se vuole convertire i litri */
  488.                         {
  489.                             risultato_parte_num = parte_numerica / 1000;
  490.                         }
  491.                         else
  492.                             if(unita_misura_da_convertire == 4 && risultato_unita_misura == 10)
  493.                             {
  494.                                 risultato_parte_num = parte_numerica * 1000;
  495.                             } /* termine litri */
  496.  
  497.                         if(unita_misura_da_convertire == 5 && risultato_unita_misura == 8) /* se vuole convertire i decilitri */
  498.                         {
  499.                             risultato_parte_num = parte_numerica / 10000;
  500.                         }
  501.                         else
  502.                             if(unita_misura_da_convertire == 5 && risultato_unita_misura == 9)
  503.                             {
  504.                                 risultato_parte_num = parte_numerica / 10;
  505.                             }
  506.                             else
  507.                                 if(unita_misura_da_convertire == 5 && risultato_unita_misura == 10)
  508.                                 {
  509.                                     risultato_parte_num = parte_numerica * 100;
  510.                                 } /* termine decilitri */
  511.  
  512.                         if(unita_misura_da_convertire == 6 && risultato_unita_misura == 8) /* se vuole convertire i centilitri */
  513.                         {
  514.                             risultato_parte_num = parte_numerica / 100000;
  515.                         }
  516.                         else
  517.                             if(unita_misura_da_convertire == 6 && risultato_unita_misura == 9)
  518.                             {
  519.                                 risultato_parte_num = parte_numerica / 100;
  520.                             }
  521.                             else
  522.                                 if(unita_misura_da_convertire == 6 && risultato_unita_misura == 10)
  523.                                 {
  524.                                     risultato_parte_num = parte_numerica * 10;
  525.                                 } /* termine centilitri */
  526.  
  527.                         if(unita_misura_da_convertire == 7 && risultato_unita_misura == 8)
  528.                         {
  529.                             risultato_parte_num = parte_numerica / 1000000;
  530.                         }
  531.                         else
  532.                             if(unita_misura_da_convertire == 7 && risultato_unita_misura == 9)
  533.                             {
  534.                                 risultato_parte_num = parte_numerica / 1000;
  535.                             } /* se vuole convertire i millilitri */
  536.  
  537.                         printf("La parte numerica risulta %.3f \n \n", risultato_parte_num);
  538.                     } /* termine if calcolo litri a metri cubi */
  539.  
  540.                 if(scelta_volume == 'n' || scelta_volume == 'N')
  541.                 {
  542.                     do
  543.                     {
  544.                         printf("Sempre seguendo la tabella di prima, digita l'unit%c di misura che vuoi ottenere: ");
  545.                         scanf("%i",&risultato_unita_misura);
  546.                         fflush(stdin);
  547.                         printf("\n");
  548.  
  549.                         if(unita_misura_da_convertire < 1 || unita_misura_da_convertire > 7 || risultato_unita_misura < 1 || risultato_unita_misura > 7)
  550.                         {
  551.                             printf("Inserimento fallito. \n");
  552.                             printf("Puoi inserire solo numeri da 1 a 7. \n");
  553.                             printf("Riprova. \n \n");
  554.                         }
  555.                                                
  556.                         if(unita_misura_da_convertire == risultato_unita_misura)
  557.                         {
  558.                             printf("Inserimento fallito. \n");
  559.                             printf("Le due unit%c di misura sono uguali. \n", 133);
  560.                             printf("Riprova. \n \n");
  561.                         }
  562.                     }
  563.                     while((unita_misura_da_convertire < 1 || unita_misura_da_convertire > 7 || risultato_unita_misura < 1 || risultato_unita_misura > 7) || (unita_misura_da_convertire == risultato_unita_misura));
  564.  
  565.                     /* Calcolo volume - litri a litri */
  566.  
  567.                     if(unita_misura_da_convertire < risultato_unita_misura) /* cosa fare se il numero dell'unità indicata inizialmente è minore rispetto a quello indicato dopo */
  568.                     {
  569.                         unita_misura_variabile = risultato_unita_misura - unita_misura_da_convertire;
  570.                     } /* fine if */
  571.                     else
  572.                         if(unita_misura_da_convertire > risultato_unita_misura) /* cosa fare se il numero dell'unità indicata inizialmente è maggiore rispetto a quello indicato dopo */
  573.                         {
  574.                             unita_misura_variabile = unita_misura_da_convertire - risultato_unita_misura;
  575.                         }   /* fine if */
  576.  
  577.                     if(unita_misura_da_convertire < risultato_unita_misura) /* se l'unità di misura inserita prima è minore rispetto a quella inserita dopo, moltiplicare il risultato */
  578.                     {
  579.                         risultato_parte_num = (parte_numerica * pow(10, unita_misura_variabile));
  580.                     } /* fine if */
  581.                     else
  582.                         if(unita_misura_da_convertire > risultato_unita_misura) /* se l'unità di misura inserita prima è maggiore rispetto a quella inserita dopo, dividere il risultato */
  583.                         {
  584.                             risultato_parte_num = (parte_numerica / pow(10, unita_misura_variabile));
  585.                         }
  586.  
  587.                     printf("La parte numerica risulta %.3f \n \n", risultato_parte_num);
  588.                 } /* termine if se vuole mantenere i litri */
  589.             } /* termine if per usare i litri */
  590.         } /* termine if del volume */
  591.  
  592.         if(scelta_iniziale == 4) /* inizio if se si sceglie di lavorare sulle superfici */
  593.         {
  594.             printf("Inserisci la misura indicandone l'unit%c: \n \n", 133);
  595.  
  596.             printf("1. Kilometri quadrati (Km%c) \n", 253);
  597.             printf("2. Ettari (ha) \n");
  598.             printf("3. Ara (a) \n");
  599.             printf("4. Metri quadrati (m%c) \n", 253);
  600.             printf("5. Decimetri quadrati (dm%c) \n", 253);
  601.             printf("6. Centimetri quadrati (cm%c) \n", 253);
  602.             printf("7. Millimetri quadrati (mm%c) \n \n", 253);
  603.  
  604.             printf("Digita la parte numerica della misura: ");
  605.             scanf("%f",&parte_numerica);
  606.             fflush(stdin);
  607.             printf("\n");
  608.  
  609.             do  /* ripetere in caso sia errato l'inserimento (numero minore di 1 o maggiore di 7) */
  610.             {
  611.                 printf("Seguendo la tabella di prima, digita il numero corrispondente all'unit%c di misura: ", 133);
  612.                 scanf("%i",&unita_misura_da_convertire);
  613.                 fflush(stdin);
  614.                 printf("\n");
  615.            
  616.                 printf("Sempre seguendo la tabella precedente, indica quale misura vuoi ottenere: ");
  617.                 scanf("%i",&risultato_unita_misura);
  618.                 fflush(stdin);
  619.                 printf("\n");
  620.  
  621.                 if((unita_misura_da_convertire < 1) || (unita_misura_da_convertire > 7) || (risultato_unita_misura < 1) || (risultato_unita_misura > 7))
  622.                 {
  623.                     printf("Inserimento fallito. \n");
  624.                     printf("Puoi inserire soltanto numeri da 1 a 7. \n");
  625.                     printf("Riprova. \n \n");
  626.                 }
  627.  
  628.                 if(unita_misura_da_convertire == risultato_unita_misura) /* if per determinare se l'unità inserita per prima e quella inserita per seconda sono uguali */
  629.                 {
  630.                     printf("Inserimento fallito. \n");
  631.                     printf("Le due unita' da te inserite sono uguali. \n");
  632.                     printf("Riprova. \n \n");
  633.                 }   /* termine if */
  634.             }
  635.             while((unita_misura_da_convertire < 1) || (unita_misura_da_convertire > 7) || (risultato_unita_misura < 1) || (risultato_unita_misura > 7) || (unita_misura_da_convertire == risultato_unita_misura));
  636.  
  637.             /* Calcolo (superficie) */
  638.  
  639.             if(unita_misura_da_convertire < risultato_unita_misura) /* cosa fare se il numero dell'unità indicata inizialmente è minore rispetto a quello indicato dopo */
  640.             {
  641.                 unita_misura_variabile = risultato_unita_misura - unita_misura_da_convertire;
  642.             } /* fine if */
  643.             else
  644.                 if(unita_misura_da_convertire > risultato_unita_misura) /* cosa fare se il numero dell'unità indicata inizialmente è maggiore rispetto a quello indicato dopo */
  645.                 {
  646.                     unita_misura_variabile = unita_misura_da_convertire - risultato_unita_misura;
  647.                 }   /* fine if */
  648.  
  649.             if(unita_misura_da_convertire < risultato_unita_misura) /* se l'unità di misura inserita prima è minore rispetto a quella inserita dopo, moltiplicare il risultato */
  650.             {
  651.                 risultato_parte_num = (parte_numerica * pow(100, unita_misura_variabile));
  652.             } /* fine if */
  653.             else
  654.                 if(unita_misura_da_convertire > risultato_unita_misura) /* se l'unità di misura inserita prima è maggiore rispetto a quella inserita dopo, dividere il risultato */
  655.                 {
  656.                     risultato_parte_num = (parte_numerica / pow(100, unita_misura_variabile));
  657.                 }
  658.  
  659.             printf("La parte numerica risulta %.3f \n \n", risultato_parte_num);
  660.         } /* termine if della superficie */
  661.  
  662.         if(scelta_iniziale == 5) /* inizio if se si sceglie di lavorare sulla temperatura */
  663.         {
  664.             printf("Inserisci la misura indicandone l'unit%c: \n \n", 133);
  665.  
  666.             printf("1. Celsius (%cC) \n", 248);
  667.             printf("2. Kelvin (K) \n \n");
  668.  
  669.             printf("Digita la parte numerica della misura: ");
  670.             scanf("%f",&parte_numerica);
  671.             fflush(stdin);
  672.             printf("\n");
  673.  
  674.             do  /* ripetere in caso sia errato l'inserimento (numero minore di 1 o maggiore di 2) */
  675.             {
  676.                 printf("Seguendo la tabella di prima, digita il numero corrispondente all'unit%c di misura: ", 133);
  677.                 scanf("%i",&unita_misura_da_convertire);
  678.                 fflush(stdin);
  679.                 printf("\n");
  680.            
  681.                 printf("Sempre seguendo la tabella precedente, indica quale misura vuoi ottenere: ");
  682.                 scanf("%i",&risultato_unita_misura);
  683.                 fflush(stdin);
  684.                 printf("\n");
  685.  
  686.                 if((unita_misura_da_convertire < 1) || (unita_misura_da_convertire > 2) || (risultato_unita_misura < 1) || (risultato_unita_misura > 2))
  687.                 {
  688.                     printf("Inserimento fallito. \n");
  689.                     printf("Puoi inserire soltanto numeri da 1 a 2. \n");
  690.                     printf("Riprova. \n \n");
  691.                 }
  692.  
  693.                 if(unita_misura_da_convertire == risultato_unita_misura) /* if per determinare se l'unità inserita per prima e quella inserita per seconda sono uguali */
  694.                 {
  695.                     printf("Inserimento fallito. \n");
  696.                     printf("Le due unita' da te inserite sono uguali. \n");
  697.                     printf("Riprova. \n \n");
  698.                 }   /* termine if */
  699.             }
  700.             while((unita_misura_da_convertire < 1) || (unita_misura_da_convertire > 2) || (risultato_unita_misura < 1) || (risultato_unita_misura > 2) || (unita_misura_da_convertire == risultato_unita_misura));
  701.  
  702.             /* Calcolo (temperatura) */
  703.  
  704.             if(unita_misura_da_convertire == 1 && risultato_unita_misura == 2) /* calcolo da eseguire se si devono trovare i Kelvin */
  705.             {
  706.                 risultato_parte_num = parte_numerica + 273.15;
  707.             }
  708.             else
  709.                 if(unita_misura_da_convertire == 2 && risultato_unita_misura == 1) /* calcolo da eseguire se si devono trovare i Celsius */
  710.                 {
  711.                     risultato_parte_num = parte_numerica - 273.15;
  712.                 }
  713.  
  714.             printf("La parte numerica risulta %.2f \n \n", risultato_parte_num);
  715.         } /* termine if della temperatura */
  716.  
  717.         if(scelta_iniziale == 6) /* inizio if se si sceglie di lavorare sul tempo */
  718.         {
  719.             printf("Inserisci la misura indicandone l'unit%c: \n \n", 133);
  720.  
  721.             printf("1. Secondi (s) \n");
  722.             printf("2. Minuti (m) \n");
  723.             printf("3. Ore (h) \n \n");
  724.  
  725.             printf("Digita la parte numerica della misura: ");
  726.             scanf("%f",&parte_numerica);
  727.             fflush(stdin);
  728.             printf("\n");
  729.  
  730.             do  /* ripetere in caso sia errato l'inserimento (numero minore di 1 o maggiore di 3) */
  731.             {
  732.                 printf("Seguendo la tabella di prima, digita il numero corrispondente all'unit%c di misura: ", 133);
  733.                 scanf("%i",&unita_misura_da_convertire);
  734.                 fflush(stdin);
  735.                 printf("\n");
  736.            
  737.                 printf("Sempre seguendo la tabella precedente, indica quale misura vuoi ottenere: ");
  738.                 scanf("%i",&risultato_unita_misura);
  739.                 fflush(stdin);
  740.                 printf("\n");
  741.  
  742.                 if((unita_misura_da_convertire < 1) || (unita_misura_da_convertire > 3) || (risultato_unita_misura < 1) || (risultato_unita_misura > 3))
  743.                 {
  744.                     printf("Inserimento fallito. \n");
  745.                     printf("Puoi inserire soltanto numeri da 1 a 3. \n");
  746.                     printf("Riprova. \n \n");
  747.                 }
  748.  
  749.                 if(unita_misura_da_convertire == risultato_unita_misura) /* if per determinare se l'unità inserita per prima e quella inserita per seconda sono uguali */
  750.                 {
  751.                     printf("Inserimento fallito. \n");
  752.                     printf("Le due unita' da te inserite sono uguali. \n");
  753.                     printf("Riprova. \n \n");
  754.                 }   /* termine if */
  755.             }
  756.             while((unita_misura_da_convertire < 1) || (unita_misura_da_convertire > 3) || (risultato_unita_misura < 1) || (risultato_unita_misura > 3) || (unita_misura_da_convertire == risultato_unita_misura));
  757.  
  758.             /* Calcolo (tempo) */
  759.  
  760.             if(unita_misura_da_convertire < risultato_unita_misura) /* cosa fare se il numero dell'unità indicata inizialmente è minore rispetto a quello indicato dopo */
  761.             {
  762.                 unita_misura_variabile = risultato_unita_misura - unita_misura_da_convertire;
  763.             } /* fine if */
  764.             else
  765.                 if(unita_misura_da_convertire > risultato_unita_misura) /* cosa fare se il numero dell'unità indicata inizialmente è maggiore rispetto a quello indicato dopo */
  766.                 {
  767.                     unita_misura_variabile = unita_misura_da_convertire - risultato_unita_misura;
  768.                 }   /* fine if */
  769.  
  770.             if(unita_misura_da_convertire < risultato_unita_misura) /* se l'unità di misura inserita prima è minore rispetto a quella inserita dopo, moltiplicare il risultato */
  771.             {
  772.                 risultato_parte_num = (parte_numerica / pow(60, unita_misura_variabile));
  773.             } /* fine if */
  774.             else
  775.                 if(unita_misura_da_convertire > risultato_unita_misura) /* se l'unità di misura inserita prima è maggiore rispetto a quella inserita dopo, dividere il risultato */
  776.                 {
  777.                     risultato_parte_num = (parte_numerica * pow(60, unita_misura_variabile));
  778.                 }
  779.  
  780.             printf("La parte numerica risulta %.3f \n \n", risultato_parte_num);
  781.         } /* termine if del tempo */
  782.  
  783.         if(scelta_iniziale == 7) /* inizio if se si sceglie di lavorare sulla memoria virtuale */
  784.         {
  785.             printf("Inserisci la misura indicandone l'unit%c: \n \n", 133);
  786.  
  787.             printf("1. Terabyte (TB) \n");
  788.             printf("2. Gigabyte (GB) \n");
  789.             printf("3. Megabyte (MB) \n");
  790.             printf("4. Kilobyte (KB) \n");
  791.             printf("5. Byte (B) \n \n");
  792.  
  793.             printf("Digita la parte numerica della misura: ");
  794.             scanf("%f",&parte_numerica);
  795.             fflush(stdin);
  796.             printf("\n");
  797.  
  798.             do  /* ripetere in caso sia errato l'inserimento (numero minore di 1 o maggiore di 5) */
  799.             {
  800.                 printf("Seguendo la tabella di prima, digita il numero corrispondente all'unit%c di misura: ", 133);
  801.                 scanf("%i",&unita_misura_da_convertire);
  802.                 fflush(stdin);
  803.                 printf("\n");
  804.            
  805.                 printf("Sempre seguendo la tabella precedente, indica quale misura vuoi ottenere: ");
  806.                 scanf("%i",&risultato_unita_misura);
  807.                 fflush(stdin);
  808.                 printf("\n");
  809.  
  810.                 if((unita_misura_da_convertire < 1) || (unita_misura_da_convertire > 5) || (risultato_unita_misura < 1) || (unita_misura_da_convertire > 5))
  811.                 {
  812.                     printf("Inserimento fallito. \n");
  813.                     printf("Puoi inserire soltanto numeri da 1 a 6. \n");
  814.                     printf("Riprova. \n \n");
  815.                 }
  816.  
  817.                 if(unita_misura_da_convertire == risultato_unita_misura) /* if per determinare se l'unità inserita per prima e quella inserita per seconda sono uguali */
  818.                 {
  819.                     printf("Inserimento fallito. \n");
  820.                     printf("Le due unita' da te inserite sono uguali. \n");
  821.                     printf("Riprova. \n \n");
  822.                 }   /* termine if */
  823.             }
  824.             while(((unita_misura_da_convertire < 1) || (unita_misura_da_convertire > 5)) || (risultato_unita_misura < 1) || (unita_misura_da_convertire > 5) || (unita_misura_da_convertire == risultato_unita_misura));
  825.  
  826.             /* Calcolo (memoria virtuale) */
  827.  
  828.             if(unita_misura_da_convertire < risultato_unita_misura) /* cosa fare se il numero dell'unità indicata inizialmente è minore rispetto a quello indicato dopo */
  829.             {
  830.                 unita_misura_variabile = risultato_unita_misura - unita_misura_da_convertire;
  831.             } /* fine if */
  832.             else
  833.                 if(unita_misura_da_convertire > risultato_unita_misura) /* cosa fare se il numero dell'unità indicata inizialmente è maggiore rispetto a quello indicato dopo */
  834.                 {
  835.                     unita_misura_variabile = unita_misura_da_convertire - risultato_unita_misura;
  836.                 }   /* fine if */
  837.  
  838.             if(unita_misura_da_convertire < risultato_unita_misura) /* se l'unità di misura inserita prima è minore rispetto a quella inserita dopo, moltiplicare il risultato */
  839.             {
  840.                 risultato_parte_num = (parte_numerica * pow(1024, unita_misura_variabile));
  841.             } /* fine if */
  842.             else
  843.                 if(unita_misura_da_convertire > risultato_unita_misura) /* se l'unità di misura inserita prima è maggiore rispetto a quella inserita dopo, dividere il risultato */
  844.                 {
  845.                     risultato_parte_num = (parte_numerica / pow(1024, unita_misura_variabile));
  846.                 }
  847.  
  848.             printf("La parte numerica risulta %.1f \n \n", risultato_parte_num);
  849.         } /* termine if della memoria virtuale */
  850.  
  851.         if(scelta_iniziale == 8) /* inizio if se si sceglie di lavorare sulla velocità */
  852.         {
  853.             printf("Inserisci la misura indicandone l'unit%c: \n \n", 133);
  854.  
  855.             printf("1. Metri al secondo (m/s) \n", 248);
  856.             printf("2. Kilometri all'ora (Km/h) \n \n");
  857.  
  858.             printf("Digita la parte numerica della misura: ");
  859.             scanf("%f",&parte_numerica);
  860.             fflush(stdin);
  861.             printf("\n");
  862.  
  863.             do  /* ripetere in caso sia errato l'inserimento (numero minore di 1 o maggiore di 2) */
  864.             {
  865.                 printf("Seguendo la tabella di prima, digita il numero corrispondente all'unit%c di misura: ", 133);
  866.                 scanf("%i",&unita_misura_da_convertire);
  867.                 fflush(stdin);
  868.                 printf("\n");
  869.            
  870.                 printf("Sempre seguendo la tabella precedente, indica quale misura vuoi ottenere: ");
  871.                 scanf("%i",&risultato_unita_misura);
  872.                 fflush(stdin);
  873.                 printf("\n");
  874.  
  875.                 if((unita_misura_da_convertire < 1) || (unita_misura_da_convertire > 2) || (risultato_unita_misura < 1) || (risultato_unita_misura > 2))
  876.                 {
  877.                     printf("Inserimento fallito. \n");
  878.                     printf("Puoi inserire soltanto numeri da 1 a 2. \n");
  879.                     printf("Riprova. \n \n");
  880.                 }
  881.  
  882.                 if(unita_misura_da_convertire == risultato_unita_misura) /* if per determinare se l'unità inserita per prima e quella inserita per seconda sono uguali */
  883.                 {
  884.                     printf("Inserimento fallito. \n");
  885.                     printf("Le due unita' da te inserite sono uguali. \n");
  886.                     printf("Riprova. \n \n");
  887.                 }   /* termine if */
  888.             }
  889.             while((unita_misura_da_convertire < 1) || (unita_misura_da_convertire > 2) || (risultato_unita_misura < 1) || (risultato_unita_misura > 2) || (unita_misura_da_convertire == risultato_unita_misura));
  890.  
  891.             /* Calcolo (velocità) */
  892.  
  893.             if(unita_misura_da_convertire == 1 && risultato_unita_misura == 2) /* calcolo da eseguire se si devono trovare i km/h */
  894.             {
  895.                 risultato_parte_num = parte_numerica * 3,6;
  896.             }
  897.             else
  898.                 if(unita_misura_da_convertire == 2 && risultato_unita_misura == 1) /* calcolo da eseguire se si devono trovare i m/s */
  899.                 {
  900.                     risultato_parte_num = parte_numerica / 3,6;
  901.                 }
  902.  
  903.             printf("La parte numerica risulta %.3f \n \n", risultato_parte_num);
  904.         } /* termine if della velocità */
  905.  
  906.         /* Crediti del programma */
  907.  
  908.         printf("Developed by %cl%ck%c%c \n \n", 128, 152, 152, 126);
  909.  
  910.         /* Scelta se ripetere o terminare */
  911.  
  912.         printf("Vuoi ripetere il programma da 0? \n");
  913.         printf("Premi 'Y' per s%c. \n", 141);
  914.         printf("Qualsiasi altro tasto per uscire. ");
  915.         fflush(stdin);
  916.         scanf("%c",&scelta_ripetizione_totale);
  917.         printf("\n");
  918.  
  919.         if(scelta_ripetizione_totale != 'y' || scelta_ripetizione_totale != 'Y')
  920.         {
  921.             printf("Hai deciso di terminare il programma. \n");
  922.             printf("Buona giornata. \n \n");
  923.         }
  924.  
  925.     } /* termine do per la ripetizione del programma */
  926.     while(scelta_ripetizione_totale == 'y' || scelta_ripetizione_totale == 'Y');
  927.  
  928. system("pause");
  929. return 0;
  930. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!