conversoes

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

void linha (int l){ //funcao que pula linhas
   int i;
      for (i=0; i<l; i++){
         printf ("\n");
      }
}

void decimal_bin (int dec1) {

   long long int res[50], i=0, tam=0;

      while (dec1!=0){
         res[i] = dec1%2;
         dec1 /= 2;
         i++;           //preenche o res[i]
         tam++;            //conta quantos lugares ocupará no vetor
      }

   long long int result[tam];

      printf ("Binario: ");
         for (i=0; i<tam; i++){
            result[i] = res[tam-1-i];           //result recebe o valor inverso do vetor res
            printf ("%lld", result[i]);
         }
               linha (1);
}

void decimal_octal (int dec2) {

   long long int res[50], i=0, tam=0;

      while (dec2!=0){
         res[i] = dec2%8;
         dec2 /= 8;
         i++;
         tam++;
      }

   long long int result[tam];

      printf ("Octal: ");
         for (i=0; i<tam; i++){
            result[i] = res[tam-1-i];
            printf ("%lld", result[i]);
         }
                  linha (1);
}

void decimal_hexa (int dec3) {

   long long int res[50], i=0, tam=0;

      while (dec3!=0){
         res[i] = dec3%16;
         dec3 /= 16;
         i++;
         tam++;
      }

   long long int result[tam];

      printf ("Hexadecimal: 0x");
         for (i=0; i<tam; i++){
            result[i] = res[tam-1-i];
              switch (result[i]){          //analisa os casos onde o numero é escrito como letra e o default;
                  case 10: printf ("A"); break;
                  case 11: printf ("B"); break;
                  case 12: printf ("C"); break;
                  case 13: printf ("D"); break;
                  case 14: printf ("E"); break;
                  case 15: printf ("F"); break;
                  default: printf ("%lld", result[i]); break;
               }
         }
                     linha (1);
}

void binario_dec (char bin1[]){

   int tamanho, i, decimal=0;

      tamanho = strlen(bin1);  //armazena o tamanho da string na variavel "tamanho"

   int vetor[tamanho], inv[tamanho];
      for (i=0; i<tamanho; i++){
         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)
      }
            for (i=0; i<tamanho; i++){
               inv[i] = vetor[tamanho-1-i];           //inverte a ordem do vetor, para melhor manipulação
            }
                  for (i=0; i<tamanho; i++){
                     inv[i] = inv[i]*(pow(2, i));              //multiplica o valor de cada bloco por 2^[posicao]
                     decimal+=inv[i];                    //a variavel "decimal" irá armazenar a soma dos valores do vetor
                  }
      printf ("Decimal: ");
         printf ("%d\n", decimal);

}

void binario_octal (char bin2[]){

   int tamanho, i, decimal=0;
   long long int res[50], t=0, tam=0;  //primeiro converteu-se para decimal

      tamanho = strlen(bin2);

   int vetor[tamanho], inv[tamanho];

      for (i=0; i<tamanho; i++){
         vetor[i] = bin2[i] - 48;
      }
            for (i=0; i<tamanho; i++){
               inv[i] = vetor[tamanho-1-i];
            }
                  for (i=0; i<tamanho; i++){
                     inv[i] = inv[i]*(pow(2, i));
                     decimal+=inv[i];               //aqui deixou-se o valor em decimal para depois aproveitar a função ja usada previamente
                  }

      while (decimal!=0){                 //aqui aproveitou-se a função que converte decimal em octal
         res[t] = decimal%8;
         decimal /= 8;
         t++;
         tam++;
      }

   long long int result[tam];

      printf ("Octal: ");
         for (t=0; t<tam; t++){
            result[t] = res[tam-1-t];
            printf ("%lld", result[t]);
         }
               linha (1);
}

void binario_hexa (char bin3[]){

   int tamanho, i, decimal=0;
   long long int res[50], h=0, tam=0;

      tamanho = strlen(bin3);

   int vetor[tamanho], inv[tamanho];

      for (i=0; i<tamanho; i++){
         vetor[i] = bin3[i] - 48;
      }
            for (i=0; i<tamanho; i++){
               inv[i] = vetor[tamanho-1-i];
            }
                  for (i=0; i<tamanho; i++){
                     inv[i] = inv[i]*(pow(2, i));
                     decimal+=inv[i];
                  }

      while (decimal!=0){
         res[h] = decimal%16;
         decimal /= 16;
         h++;
         tam++;
      }

   long long int result[tam];

      printf ("Hexadecimal: 0x");

      for (h=0; h<tam; h++){
         result[h] = res[tam-1-h];
            switch (result[h]){
               case 10: printf ("A"); break;
               case 11: printf ("B"); break;
               case 12: printf ("C"); break;
               case 13: printf ("D"); break;
               case 14: printf ("E"); break;
               case 15: printf ("F"); break;
               default: printf ("%lld", result[h]); break;
            }
      }
                  linha (1);
}

void octal_dec (char oct1[]){

   int tamanho, i, decimal=0;

      tamanho = strlen(oct1);

   int vetor[tamanho], inv[tamanho];

      for (i=0; i<tamanho; i++){
         vetor[i] = oct1[i] - 48;
      }
            for (i=0; i<tamanho; i++){
               inv[i] = vetor[tamanho-1-i];
            }
                  for (i=0; i<tamanho; i++){
                     inv[i] = inv[i]*(pow(8, i));
                     decimal+=inv[i];
                  }
      printf ("Decimal: ");
         printf ("%d\n", decimal);

            linha(1);
}

void octal_bin (char oct2[]){

int tamanho, x, decimal=0; //primeiro usa-se a funcao para converter em decimal, em seguida, binario
long long int res[50], i=0, tam=0;

   tamanho = strlen(oct2);

   int vetor[tamanho], inv[tamanho];
      for (x=0; x<tamanho; x++){
         vetor[x] = oct2[x] - 48;
      }
            for (x=0; x<tamanho; x++){
               inv[x] = vetor[tamanho-1-x];
            }
                  for (x=0; x<tamanho; x++){
                     inv[x] = inv[x]*(pow(8, x));
                     decimal+=inv[x];
                  }

      while (decimal!=0){
         res[i] = decimal%2;
         decimal /= 2;
         i++;
         tam++;
      }

   long long int result[tam];

      printf ("Binario: ");
         for (i=0; i<tam; i++){
            result[i] = res[tam-1-i];
            printf ("%lld", result[i]);
         }
               linha (1);
}

void octal_hexa (char oct3[]){

   int tamanho, x, decimal=0;
   long long int res[50], i=0, tam=0;

   tamanho = strlen(oct3);

   int vetor[tamanho], inv[tamanho];
      for (x=0; x<tamanho; x++){
         vetor[x] = oct3[x] - 48;
      }
            for (x=0; x<tamanho; x++){
               inv[x] = vetor[tamanho-1-x];
            }
                  for (x=0; x<tamanho; x++){
                     inv[x] = inv[x]*(pow(8, x));
                     decimal+=inv[x];
                  }

      while (decimal!=0){
         res[i] = decimal%16;
         decimal /= 16;
         i++;
         tam++;
      }

   long long int result[tam];

      printf ("Hexadecimal: 0x");
         for (i=0; i<tam; i++){
            result[i] = res[tam-1-i];
               switch (result[i]){
                  case 10: printf ("A"); break;
                  case 11: printf ("B"); break;
                  case 12: printf ("C"); break;
                  case 13: printf ("D"); break;
                  case 14: printf ("E"); break;
                  case 15: printf ("F"); break;
                  default: printf ("%lld", result[i]); break;
               }
         }
            linha (1);
}

void hexa_dec (char hexa1[]){

int tamanho, i, t, decimal=0;

   tamanho = strlen(hexa1);

int vetor[tamanho], inv[tamanho];

   printf ("Decimal: ");

      for (t=0; t<tamanho; t++){
         if (hexa1[t]>='0' && hexa1[t]<='9'){         //condição somente para os numeros
            vetor[t] = hexa1[t] - 48;
         }
            else if (hexa1[t]>='A' && hexa1[t]<='F'){   //condição para as letras
               vetor[t] = hexa1[t] - 55;         //na tabela ASCII, se fizermos A(65) - 55, nos da o valor 10, que equivale ao A
            }
               else if (hexa1[t]>='a' && hexa1[t]<='f'){
                  vetor[t] = hexa1[t] - 87;
               }
      }
                     for (i=0; i<tamanho; i++){
                        inv[i] = vetor[tamanho-1-i];
                     }
                           for (i=0; i<tamanho; i++){
                              inv[i] = inv[i]*(pow(16, i));
                              decimal+=inv[i];
                           }
                                 printf ("%d\n", decimal);
}

void hexa_bin (char hexa2[]){

int tamanho, x, t, decimal=0;
long long int res[50], i=0, tam=0;

   tamanho = strlen(hexa2);

int vetor[tamanho], inv[tamanho];

      for (t=0; t<tamanho; t++){
         if (hexa2[t]>='0' && hexa2[t]<='9'){
            vetor[t] = hexa2[t] - 48;
         }
            else if (hexa2[t]>='A' && hexa2[t]<='F'){
               vetor[t] = hexa2[t] - 55;
            }
               else if (hexa2[t]>='a' && hexa2[t]<='f'){
                  vetor[t] = hexa2[t] - 87;
               }
      }
                     for (x=0; x<tamanho; x++){
                        inv[x] = vetor[tamanho-1-x];
                     }
                           for (x=0; x<tamanho; x++){
                              inv[x] = inv[x]*(pow(16, x));
                              decimal+=inv[x];
                           }

      while (decimal!=0){
         res[i] = decimal%2;
         decimal /= 2;
         i++;
         tam++;
      }

   long long int result[tam];

      printf ("Binario: ");
         for (i=0; i<tam; i++){
            result[i] = res[tam-1-i];
            printf ("%lld", result[i]);
         }
               linha (1);
}

void hexa_oct (char hexa3[]){

int tamanho, x, t, decimal=0;
long long int res[50], i=0, tam=0;

   tamanho = strlen(hexa3);

   int vetor[tamanho], inv[tamanho];

      for (t=0; t<tamanho; t++){
         if (hexa3[t]>='0' && hexa3[t]<='9'){
            vetor[t] = hexa3[t] - 48;
         }
            else if (hexa3[t]>='A' && hexa3[t]<='F'){
               vetor[t] = hexa3[t] - 55;
            }
               else if (hexa3[t]>='a' && hexa3[t]<='f'){
                  vetor[t] = hexa3[t] - 87;
               }
      }
                     for (x=0; x<tamanho; x++){
                        inv[x] = vetor[tamanho-1-x];
                     }
                           for (x=0; x<tamanho; x++){
                              inv[x] = inv[x]*(pow(16, x));
                              decimal+=inv[x];
                           }

      while (decimal!=0){
         res[i] = decimal%8;
         decimal /= 8;
         i++;
         tam++;
      }

   long long int result[tam];

      printf ("Octal: ");
         for (i=0; i<tam; i++){
            result[i] = res[tam-1-i];
            printf ("%lld", result[i]);
         }
               linha (1);
}

int main (){

      long long int num;
      char string[50];
      int opc;

      printf ("\tConvers\744es de Bases\n");
      printf ("\n\tAluno(s): Let\641cia Torres e Hendric Cechinato");
      linha(1);
      inicio:;
      linha(2);
      printf ("\tConvers\744es:\n\n");
      printf ("\t\t1 - Decimal para Binario\n\t\t2 - Decimal para Octal\n\t\t3 - Decimal para Hexadecimal\n\n");
      printf ("\t\t4 - Binario para Decimal\n\t\t5 - Binario para Octal\n\t\t6 - Binario para Hexadecimal\n\n");
      printf ("\t\t7 - Octal para Decimal\n\t\t8 - Octal para Binario\n\t\t9 - Octal para Hexadecimal\n\n");
      printf ("\t\t10 - Hexadecimal para Decimal\n\t\t11 - Hexadecimal para Binario\n\t\t12 - Hexadecimal para Octal\n\n");
      linha (1);
      printf ("Op\207\706o: ");
      scanf ("%d", &opc);

         switch (opc){
         case 1:
            printf ("\nValor: ");
            scanf ("%lld", &num);
            linha(1);
            decimal_bin (num);
            break;
         case 2:
            printf ("\nValor: ");
            scanf ("%lld", &num);
            linha(1);
            decimal_octal (num);
            break;
         case 3:
            printf ("\nValor: ");
            scanf ("%lld", &num);
            linha(1);
            decimal_hexa (num);
            break;
         case 4:
            printf ("\nValor: ");
            scanf ("%s", &string);
            linha(1);
            binario_dec(string);
            break;
         case 5:
            printf ("\nValor: ");
            scanf ("%s", &string);
            linha(1);
            binario_octal(string);
            break;
         case 6:
            printf ("\nValor: ");
            scanf ("%s", &string);
            linha(1);
            binario_hexa(string);
            break;
         case 7:
            printf ("\nValor: ");
            scanf ("%s", &string);
            linha(1);
            octal_dec(string);
            break;
         case 8:
            printf ("\nValor: ");
            scanf ("%s", &string);
            linha (1);
            octal_bin(string);
            break;
         case 9:
            printf ("\nValor: ");
            scanf ("%s", &string);
            linha (1);
            octal_hexa(string);
            break;
         case 10:
            printf ("\nValor: ");
            scanf ("%s", &string);
            linha (1);
            hexa_dec(string);
            break;
         case 11:
            printf ("\nValor: ");
            scanf ("%s", &string);
            linha (1);
            hexa_bin(string);
            break;
         case 12:
            printf ("\nValor: ");
            scanf ("%s", &string);
            linha (1);
            hexa_oct(string);
            break;
         default:
            linha(1);
            printf ("\nNao foi possivel acessar a opcao. Digite novamente:");
            goto inicio;
         }
return 0;
}