atorresleticia

Ex. 1 - Trabalho ALG+ICC (Conversões)

Jul 18th, 2014
223
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 14.22 KB | None | 0 0
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <math.h>
  4.  
  5. void linha (int l){ //funcao que pula linhas
  6.    int i;
  7.    for (i=0; i<l; i++){
  8.       printf ("\n");
  9.    }
  10. }
  11.  
  12. void decimal_bin (int dec1) {
  13.  
  14.    long long int res[50], i=0, tam=0;
  15.       while (dec1!=0){
  16.          res[i] = dec1%2;
  17.          dec1 /= 2;
  18.          i++;           //preenche o res[i]
  19.          tam++;            //conta quantos lugares ocupará no vetor
  20.       }
  21.  
  22.    long long int result[tam];
  23.  
  24.       printf ("O numero em binario vale: ");
  25.       for (i=0; i<tam; i++){
  26.          result[i] = res[tam-1-i];           //result recebe o valor inverso do vetor res
  27.          printf ("%lld", result[i]);
  28.       }
  29.       linha (1);
  30. }
  31.  
  32. void decimal_octal (int dec2) {
  33.  
  34. long long int res[50], i=0, tam=0;
  35.       while (dec2!=0){
  36.          res[i] = dec2%8;
  37.          dec2 /= 8;
  38.          i++;
  39.          tam++;
  40.       }
  41.  
  42.    long long int result[tam];
  43.  
  44.       printf ("O numero em octal vale: ");
  45.       for (i=0; i<tam; i++){
  46.          result[i] = res[tam-1-i];
  47.          printf ("%lld", result[i]);
  48.       }
  49.       linha (1);
  50. }
  51.  
  52. void decimal_hexa (int dec3) {
  53.  
  54. long long int res[50], i=0, tam=0;
  55.  
  56.       while (dec3!=0){
  57.          res[i] = dec3%16;
  58.          dec3 /= 16;
  59.          i++;
  60.          tam++;
  61.       }
  62.  
  63.    long long int result[tam];
  64.  
  65.       printf ("O numero em hexadecimal vale: ");
  66.       for (i=0; i<tam; i++){
  67.          result[i] = res[tam-1-i];
  68.             switch (result[i]){          //analisa os casos onde o numero é escrito como letra e o default;
  69.             case 10:
  70.                printf ("A");
  71.                break;
  72.             case 11:
  73.                printf ("B");
  74.                break;
  75.             case 12:
  76.                printf ("C");
  77.                break;
  78.             case 13:
  79.                printf ("D");
  80.                break;
  81.             case 14:
  82.                printf ("E");
  83.                break;
  84.             case 15:
  85.                printf ("F");
  86.                break;
  87.             default:
  88.                printf ("%lld", result[i]);
  89.                break;
  90.             }
  91.       }
  92.       linha (1);
  93. }
  94.  
  95. void binario_dec (char bin1[]){
  96.  
  97.    int tamanho, i, decimal=0;
  98.    tamanho = strlen(bin1);             //armazena o tamanho da string na variavel "tamanho"
  99.    int vetor[tamanho], inv[tamanho];
  100.       for (i=0; i<tamanho; i++){
  101.          vetor[i] = bin1[i] - 48;         //o vetor int armazena os valores da string menos o 0 (na tabela ascii, 0=48, e se pegarmos, 1(49)-48, temos o valor de 1)
  102.       }
  103.  
  104.       for (i=0; i<tamanho; i++){
  105.          inv[i] = vetor[tamanho-1-i];           //inverte a ordem do vetor, para melhor manipulação
  106.       }
  107.       for (i=0; i<tamanho; i++){
  108.          inv[i] = inv[i]*(pow(2, i));              //multiplica o valor de cada bloco por 2^[posicao]
  109.          decimal+=inv[i];                    //a variavel "decimal" irá armazenar a soma dos valores do vetor
  110.       }
  111.       printf ("O valor de binario para decimal vale: ");
  112.          printf ("%d\n", decimal);
  113.  
  114. }
  115.  
  116. void binario_octal (char bin2[]){
  117.  
  118.    int tamanho, i, decimal=0;
  119.    long long int res[50], t=0, tam=0;  //primeiro converteu-se para decimal
  120.    tamanho = strlen(bin2);
  121.  
  122.    int vetor[tamanho], inv[tamanho];
  123.  
  124.       for (i=0; i<tamanho; i++){
  125.          vetor[i] = bin2[i] - 48;
  126.       }
  127.       for (i=0; i<tamanho; i++){
  128.          inv[i] = vetor[tamanho-1-i];
  129.       }
  130.       for (i=0; i<tamanho; i++){
  131.          inv[i] = inv[i]*(pow(2, i));
  132.          decimal+=inv[i];               //aqui deixou-se o valor em decimal para depois aproveitar a função ja usada previamente
  133.       }
  134.       while (decimal!=0){                 //aqui aproveitou-se a função que converte decimal em octal
  135.          res[t] = decimal%8;
  136.          decimal /= 8;
  137.          t++;
  138.          tam++;
  139.       }
  140.  
  141.    long long int result[tam];
  142.  
  143.       printf ("O numero de binario para octal vale: ");
  144.       for (t=0; t<tam; t++){
  145.          result[t] = res[tam-1-t];
  146.          printf ("%lld", result[t]);
  147.       }
  148.       linha (1);
  149. }
  150.  
  151. void binario_hexa (char bin3[]){
  152.  
  153.    int tamanho, i, emdecimal=0;
  154.    long long int res[50], h=0, tam=0;
  155.    tamanho = strlen(bin3);
  156.  
  157.    int vetor[tamanho], inv[tamanho];
  158.  
  159.       for (i=0; i<tamanho; i++){
  160.          vetor[i] = bin3[i] - 48;
  161.       }
  162.       for (i=0; i<tamanho; i++){
  163.          inv[i] = vetor[tamanho-1-i];
  164.       }
  165.       for (i=0; i<tamanho; i++){
  166.          inv[i] = inv[i]*(pow(2, i));
  167.          emdecimal+=inv[i];
  168.       }
  169.       while (emdecimal!=0){
  170.          res[h] = emdecimal%16;
  171.          emdecimal /= 16;
  172.          h++;
  173.          tam++;
  174.       }
  175.  
  176.    long long int result[tam];
  177.  
  178.       printf ("O numero em hexadecimal vale: ");
  179.       for (h=0; h<tam; h++){
  180.          result[h] = res[tam-1-h];
  181.             switch (result[h]){
  182.             case 10:
  183.                printf ("A");
  184.                break;
  185.             case 11:
  186.                printf ("B");
  187.                break;
  188.             case 12:
  189.                printf ("C");
  190.                break;
  191.             case 13:
  192.                printf ("D");
  193.                break;
  194.             case 14:
  195.                printf ("E");
  196.                break;
  197.             case 15:
  198.                printf ("F");
  199.                break;
  200.             default:
  201.                printf ("%lld", result[h]);
  202.                break;
  203.  
  204.             }
  205.       }
  206.       linha (1);
  207. }
  208.  
  209. void octal_dec (char oct1[]){
  210.  
  211.    int tamanho, i, decimal=0;
  212.    tamanho = strlen(oct1);
  213.    int vetor[tamanho], inv[tamanho];
  214.       for (i=0; i<tamanho; i++){
  215.          vetor[i] = oct1[i] - 48;
  216.       }
  217.       for (i=0; i<tamanho; i++){
  218.          inv[i] = vetor[tamanho-1-i];
  219.       }
  220.       for (i=0; i<tamanho; i++){
  221.          inv[i] = inv[i]*(pow(8, i));
  222.          decimal+=inv[i];
  223.       }
  224.       printf ("O valor de octal para decimal vale: ");
  225.          printf ("%d\n", decimal);
  226. }
  227.  
  228. void octal_bin (char oct2[]){
  229.  
  230. int tamanho, x, decimal=0; //primeiro usa-se a funcao para converter em decimal, em seguida, binario
  231. long long int res[50], i=0, tam=0;
  232.    tamanho = strlen(oct2);
  233.    int vetor[tamanho], inv[tamanho];
  234.       for (x=0; x<tamanho; x++){
  235.          vetor[x] = oct2[x] - 48;
  236.       }
  237.       for (x=0; x<tamanho; x++){
  238.          inv[x] = vetor[tamanho-1-x];
  239.       }
  240.       for (x=0; x<tamanho; x++){
  241.          inv[x] = inv[x]*(pow(8, x));
  242.          decimal+=inv[x];
  243.       }
  244.  
  245.       while (decimal!=0){
  246.          res[i] = decimal%2;
  247.          decimal /= 2;
  248.          i++;
  249.          tam++;
  250.       }
  251.  
  252.    long long int result[tam];
  253.  
  254.       printf ("O numero de octal para binario vale: ");
  255.       for (i=0; i<tam; i++){
  256.          result[i] = res[tam-1-i];
  257.          printf ("%lld", result[i]);
  258.       }
  259.       linha (1);
  260. }
  261.  
  262. void octal_hexa (char oct3[]){
  263.  
  264.    int tamanho, x, decimal=0;
  265.    long long int res[50], i=0, tam=0;
  266.    tamanho = strlen(oct3);
  267.    int vetor[tamanho], inv[tamanho];
  268.       for (x=0; x<tamanho; x++){
  269.          vetor[x] = oct3[x] - 48;
  270.       }
  271.       for (x=0; x<tamanho; x++){
  272.          inv[x] = vetor[tamanho-1-x];
  273.       }
  274.       for (x=0; x<tamanho; x++){
  275.          inv[x] = inv[x]*(pow(8, x));
  276.          decimal+=inv[x];
  277.       }
  278.       while (decimal!=0){
  279.          res[i] = decimal%16;
  280.          decimal /= 16;
  281.          i++;
  282.          tam++;
  283.       }
  284.  
  285.    long long int result[tam];
  286.  
  287.       printf ("O numero de octal para hexadecimal vale: ");
  288.       for (i=0; i<tam; i++){
  289.          result[i] = res[tam-1-i];
  290.             switch (result[i]){
  291.             case 10:
  292.                printf ("A");
  293.                break;
  294.             case 11:
  295.                printf ("B");
  296.                break;
  297.             case 12:
  298.                printf ("C");
  299.                break;
  300.             case 13:
  301.                printf ("D");
  302.                break;
  303.             case 14:
  304.                printf ("E");
  305.                break;
  306.             case 15:
  307.                printf ("F");
  308.                break;
  309.             default:
  310.                printf ("%lld", result[i]);
  311.                break;
  312.  
  313.             }
  314.       }
  315.       linha (1);
  316. }
  317.  
  318. void hexa_dec (char hexa1[]){
  319.  
  320. int tamanho, i, t, decimal=0;
  321.  
  322.    tamanho = strlen(hexa1);
  323.  
  324. int vetor[tamanho], inv[tamanho];
  325.  
  326.    printf ("O valor de hexadecimal para decimal vale: ");
  327.  
  328.    for (t=0; t<tamanho; t++){
  329.       if (hexa1[t]>='0' && hexa1[t]<='9'){         //condição somente para os numeros
  330.             vetor[t] = hexa1[t] - 48;
  331.       } else if (hexa1[t]>='A' && hexa1[t]<='F'){   //condição para as letras
  332.             vetor[t] = hexa1[t] - 55;         //na tabela ASCII, se fizermos A(65) - 55, nos da o valor 10, que equivale ao A
  333.       }
  334.    }
  335.          for (i=0; i<tamanho; i++){
  336.             inv[i] = vetor[tamanho-1-i];
  337.          }
  338.          for (i=0; i<tamanho; i++){
  339.             inv[i] = inv[i]*(pow(16, i));
  340.             decimal+=inv[i];
  341.          }
  342.                printf ("%d\n", decimal);
  343. }
  344.  
  345. void hexa_bin (char hexa2[]){
  346.  
  347. int tamanho, x, t, decimal=0;
  348. long long int res[50], i=0, tam=0;
  349.  
  350.    tamanho = strlen(hexa2);
  351.  
  352. int vetor[tamanho], inv[tamanho];
  353.  
  354.       for (t=0; t<tamanho; t++){
  355.       if (hexa2[t]>='0' && hexa2[t]<='9'){
  356.             vetor[t] = hexa2[t] - 48;
  357.       } else if (hexa2[t]>='A' && hexa2[t]<='F'){
  358.             vetor[t] = hexa2[t] - 55;
  359.       }
  360.    }
  361.  
  362.       for (x=0; x<tamanho; x++){
  363.          inv[x] = vetor[tamanho-1-x];
  364.       }
  365.       for (x=0; x<tamanho; x++){
  366.          inv[x] = inv[x]*(pow(16, x));
  367.          decimal+=inv[x];
  368.       }
  369.  
  370.       while (decimal!=0){
  371.          res[i] = decimal%2;
  372.          decimal /= 2;
  373.          i++;
  374.          tam++;
  375.       }
  376.  
  377.    long long int result[tam];
  378.  
  379.       printf ("O numero de hexadecimal para binario vale: ");
  380.       for (i=0; i<tam; i++){
  381.          result[i] = res[tam-1-i];
  382.          printf ("%lld", result[i]);
  383.       }
  384.       linha (1);
  385. }
  386.  
  387. void hexa_oct (char hexa3[]){
  388.  
  389. int tamanho, x, t, decimal=0;
  390. long long int res[50], i=0, tam=0;
  391.  
  392.    tamanho = strlen(hexa3);
  393.  
  394.    int vetor[tamanho], inv[tamanho];
  395.  
  396.    for (t=0; t<tamanho; t++){
  397.       if (hexa3[t]>='0' && hexa3[t]<='9'){
  398.             vetor[t] = hexa3[t] - 48;
  399.       } else if (hexa3[t]>='A' && hexa3[t]<='F'){
  400.             vetor[t] = hexa3[t] - 55;
  401.       }
  402.    }
  403.  
  404.       for (x=0; x<tamanho; x++){
  405.          inv[x] = vetor[tamanho-1-x];
  406.       }
  407.       for (x=0; x<tamanho; x++){
  408.          inv[x] = inv[x]*(pow(16, x));
  409.          decimal+=inv[x];
  410.       }
  411.  
  412.       while (decimal!=0){
  413.          res[i] = decimal%8;
  414.          decimal /= 8;
  415.          i++;
  416.          tam++;
  417.       }
  418.  
  419.    long long int result[tam];
  420.  
  421.       printf ("O numero de hexadecimal para octal vale: ");
  422.       for (i=0; i<tam; i++){
  423.          result[i] = res[tam-1-i];
  424.          printf ("%lld", result[i]);
  425.       }
  426.       linha (1);
  427. }
  428.  
  429. int main (){
  430.  
  431.       int opc;
  432.       long long int num;
  433.       char string[50];
  434.       printf ("Unioeste - Universidade Estadual do Oeste do Parana\n");
  435.       printf ("Ciencia da Computacao\n");
  436.       printf ("Conversoes de Bases - Materia de Algoritmo e ICC\n");
  437.       printf ("Data: 21/07/2014");
  438.       printf ("Aluno(a): Leticia Torres");
  439.       linha(5);
  440.       printf ("\tDigite a opcao:\n");
  441.       inicio:;
  442.       linha(2);
  443.       printf ("\t1 - Decimal para Binario\n\t2 - Decimal para Octal\n\t3 - Decimal para Hexadecimal\n\n");
  444.       printf ("\t4 - Binario para Decimal\n\t5 - Binario para Octal\n\t6 - Binario para Hexadecimal\n\n");
  445.       printf ("\t7 - Octal para Decimal\n\t8 - Octal para Binario\n\t9 - Octal para Hexadecimal\n\n");
  446.       printf ("\t10 - Hexadecimal para Decimal\n\t11 - Hexadecimal para Binario\n\t12 - Hexadecimal para Octal\n\n");
  447.       linha (2);
  448.       scanf ("%d", &opc);
  449.  
  450.          switch (opc){
  451.          case 1:
  452.             printf ("\nDigite um numero decimal a ser convertido para binario: ");
  453.             scanf ("%lld", &num);
  454.             linha(1);
  455.             decimal_bin (num);
  456.             break;
  457.          case 2:
  458.             printf ("\nDigite um numero decimal a ser convertido para octal: ");
  459.             scanf ("%lld", &num);
  460.             linha(1);
  461.             decimal_octal (num);
  462.             break;
  463.          case 3:
  464.             printf ("\nDigite um numero decimal a ser convertido para hexadecimal: ");
  465.             scanf ("%lld", &num);
  466.             linha(1);
  467.             decimal_hexa (num);
  468.             break;
  469.          case 4:
  470.             printf ("\nDigite o numero binario (0 e 1) a ser convertido para decimal: ");
  471.             scanf ("%s", &string);
  472.             linha(1);
  473.             binario_dec(string);
  474.             break;
  475.          case 5:
  476.             printf ("Digite o numero binario (0 e 1) a ser convertido para octal: ");
  477.             scanf ("%s", &string);
  478.             linha(1);
  479.             binario_octal(string);
  480.             break;
  481.          case 6:
  482.             printf ("Digite o numero binario (0 e 1) a ser convertido em hexadecimal: ");
  483.             scanf ("%s", &string);
  484.             linha(1);
  485.             binario_hexa(string);
  486.             break;
  487.          case 7:
  488.             printf ("Digite o numero octal (0 a 7) a ser convertido em decimal: ");
  489.             scanf ("%s", &string);
  490.             linha(1);
  491.             octal_dec(string);
  492.             break;
  493.          case 8:
  494.             printf ("Digite o numero octal (0 a 7) a ser convertido em binario: ");
  495.             scanf ("%s", &string);
  496.             linha (1);
  497.             octal_bin(string);
  498.             break;
  499.          case 9:
  500.             printf ("Digite o numero octal (0 a 7) a ser convertido em hexadecimal: ");
  501.             scanf ("%s", &string);
  502.             linha (1);
  503.             octal_hexa(string);
  504.             break;
  505.          case 10:
  506.             printf ("Digite o numero hexadecimal a ser convertido em decimal: ");
  507.             scanf ("%s", &string);
  508.             linha (1);
  509.             hexa_dec(string);
  510.             break;
  511.          case 11:
  512.             printf ("Digite o numero hexadecimal a ser convertido em binario: ");
  513.             scanf ("%s", &string);
  514.             linha (1);
  515.             hexa_bin(string);
  516.             break;
  517.          case 12:
  518.             printf ("Digite o numero hexadecimal a ser convertido em octal: ");
  519.             scanf ("%s", &string);
  520.             linha (1);
  521.             hexa_oct(string);
  522.             break;
  523.          default:
  524.             linha(1);
  525.             printf ("Nao foi possivel acessar a opcao. Digite novamente:");
  526.             goto inicio;
  527.  
  528.          }
  529.    }
Advertisement
Add Comment
Please, Sign In to add comment